diff --git a/ReportImp/PflegedienstRahnFreitag/Calculations/CustomGroupDurationCalculator.cs b/ReportImp/PflegedienstRahnFreitag/Calculations/CustomGroupDurationCalculator.cs new file mode 100644 index 000000000..c12e4220d --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Calculations/CustomGroupDurationCalculator.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using BeWo.Service.Plugins; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.Services; + +namespace TemplateNeuKunde.Calculations +{ + //public class CustomGroupDurationCalculator : GroupDurationCalculator + //{ + // public override GroupDurationDC CalculateGroupDuration(int personCount, int employeeCount, decimal totalDuration) + // { + // return new GroupDurationDC() + // { + // SingleDuration = (totalDuration / personCount) * employeeCount, + // TotalDuration = totalDuration + // }; + // } + + //} +} diff --git a/ReportImp/PflegedienstRahnFreitag/Calculations/DefaultCalculations.cs b/ReportImp/PflegedienstRahnFreitag/Calculations/DefaultCalculations.cs new file mode 100644 index 000000000..906e9d981 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Calculations/DefaultCalculations.cs @@ -0,0 +1,25 @@ +using System; + +namespace TemplateNeuKunde.Calculations +{ + + //public class DefaultCalculations : BS.Shared.Services.Calculations + //{ + // public override int GetRoundedDuration(int minuteInterval, decimal durationInMinutes) + // { + // decimal lRoundedDuration = durationInMinutes; + + // if (minuteInterval > 0 && durationInMinutes >= 5) + // { + // lRoundedDuration = durationInMinutes % minuteInterval != 0 + // ? durationInMinutes + (minuteInterval - (durationInMinutes % minuteInterval)) + // : durationInMinutes; + // } + + // return (int)Math.Round(lRoundedDuration, 0, MidpointRounding.AwayFromZero); + // } + + + + //} +} \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Invoicing/CollectiveInvoiceCreation.cs b/ReportImp/PflegedienstRahnFreitag/Invoicing/CollectiveInvoiceCreation.cs new file mode 100644 index 000000000..a3e7ac958 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Invoicing/CollectiveInvoiceCreation.cs @@ -0,0 +1,226 @@ +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 PflegedienstRahnFreitag.Invoicing +{ + public class CollectiveInvoiceCreation : InvoiceCreation + { + private DateTime? accountingPeriodStart = null; + private DateTime? accountingPeriodEnd = null; + private decimal AMOUNT_PER_KMQA = 0.0263m; + private decimal AMOUNT_PER_KMKA = 0.0108m; + + + public override void SetInvoiceId(ServiceInvoice invoice) + { + invoice.InvoiceBase.InvoiceId = "Sammelrechnung"; + invoice.InvoiceBase.InvoiceTypeText = "Sammelrechnung LWV"; + } + + public override void SetInvoiceBaseData(int invoiceCounter, ServiceInvoice invoice, CostBearer costBearer, DateTimeSpan invoicePeriod, + IList supportConceptList) + { + if (invoicePeriod != null) + { + accountingPeriodStart = invoicePeriod.StartDate; + accountingPeriodEnd = invoicePeriod.EndDate; + var preise = DAOFactory.GenericDAO.GetAllActive(); + var pauschVar = GetPreis(preise, "Fahrtpreis QA", (DateTime)accountingPeriodStart); + if (pauschVar != 0) + { + AMOUNT_PER_KMQA = pauschVar; + } + pauschVar = 0; + pauschVar = GetPreis(preise, "Fahrtpreis KA", (DateTime)accountingPeriodStart); + if (pauschVar != 0) + { + AMOUNT_PER_KMKA = pauschVar; + } + } + base.SetInvoiceBaseData(invoiceCounter, invoice, costBearer, invoicePeriod, supportConceptList); + } + + public override void SetInvoiceItems(ServiceInvoice invoice, + ServiceInvoicePeriod serviceInvoicePeriod, + SupportConceptApprovalPeriodDC supportConceptApprovalPeriod, + CostBearer2SupportConcept cb2sc, + DateTimeSpan invoicePeriod, + List serviceRecords) + { + BS.Shared.Services.Calculations calc = PluginLoader.FindClass(_SpecificID) ?? BS.Shared.Services.Calculations.GetInstance(_SpecificID); + CreateFixedAmounts(serviceInvoicePeriod, supportConceptApprovalPeriod, cb2sc); + } + + + public override void CreateFixedAmounts(ServiceInvoicePeriod serviceInvoicePeriod, SupportConceptApprovalPeriodDC supportConceptApprovalPeriod, CostBearer2SupportConcept cb2sc) + { + var calc = PluginLoader.FindClass(_SpecificID) ?? BS.Shared.Services.Calculations.GetInstance(_SpecificID); + var data = calc.GetFixedBillingData(supportConceptApprovalPeriod, serviceInvoicePeriod.Start, serviceInvoicePeriod.End); + DateTime start = accountingPeriodStart.Value; + DateTime end = accountingPeriodEnd.Value; + if (supportConceptApprovalPeriod.StartDate > start) + { + start = supportConceptApprovalPeriod.StartDate.Value; + } + if (supportConceptApprovalPeriod.EndDate < end) + { + end = supportConceptApprovalPeriod.EndDate.Value; + } + + if (supportConceptApprovalPeriod.ServiceCategory != null) + { + var ii = new InvoiceItem + { + ItemPeriodStart = serviceInvoicePeriod.Start, + ItemPeriodEnd = serviceInvoicePeriod.End, + SupportConceptApprovalPeriodOid = supportConceptApprovalPeriod.SupportConceptApprovalPeriodOid, + AccountingInterval = AccountingIntervalType.Daily, + UnitCount = (decimal)(end - start).TotalDays + 1, + Notice = "keine Minuten" + }; + if (supportConceptApprovalPeriod.ApprovedBEPerInterval.HasValue) + { + ii.Notice = String.Format("{0:n0}", supportConceptApprovalPeriod.ApprovedBEPerInterval.Value); + if (supportConceptApprovalPeriod.ServiceCategory.Name.Contains("Fahrzeit")) + { + if (supportConceptApprovalPeriod.ServiceCategory.Name.ToLower().Contains("ka")) + { + ii.AmountPerUnit = supportConceptApprovalPeriod.ApprovedBEPerInterval * AMOUNT_PER_KMKA; + ii.ItemDescription = "KA Fahrzeit"; + } + else + { + ii.AmountPerUnit = supportConceptApprovalPeriod.ApprovedBEPerInterval * AMOUNT_PER_KMQA; + ii.ItemDescription = "QA Fahrzeit"; + } + } + else + { + if (supportConceptApprovalPeriod.ServiceCategory.Name.ToLower().Contains("ka")) + { + ii.AmountPerUnit = supportConceptApprovalPeriod.ApprovedBEPerInterval * (decimal)Math.Round((double)data[0].AmountTotal / 60, 4, MidpointRounding.AwayFromZero); + ii.ItemDescription = "KA"; + } + else + { + var LG = (decimal)GetLeistungsgruppe(supportConceptApprovalPeriod.ApprovedBEPerInterval); + if (data.Count > 0 && data[0].AmountTotal != null) + { + ii.AmountPerUnit = (decimal)Math.Round((double)data[0].AmountTotal * Math.Round((double)LG / 60, 2, MidpointRounding.AwayFromZero), 2, MidpointRounding.AwayFromZero); + //ii.AmountPerUnit = LG * (decimal)Math.Round((double)data[0].AmountTotal / 60, 4, MidpointRounding.AwayFromZero); + } + ii.ItemDescription = "QA "; + ii.ItemDescription += "LG " + GetLeistungsgruppennummer(LG); + ii.Notice = LG.ToString(); + } + if (data.Count == 1 && data[0].AmountPerUnit != null) // so können Sie mit Betrag pauschal pro Tag, ggf. adjustieren + { + ii.AmountPerUnit = data[0].AmountPerUnit; + ii.UnitCount = data[0].UnitCount; + } + } + + ii.AmountPerUnit = Math.Round((decimal)ii.AmountPerUnit, 2, MidpointRounding.AwayFromZero); + ii.AmountTotal = ii.UnitCount * ii.AmountPerUnit; + ii.GrossAmountTotal = ii.AmountTotal; + } + serviceInvoicePeriod.InvoiceItemList.Add(ii); + } + } + + private static decimal GetPreis(IList allePreise, String name, DateTime datum) + { + var pausch = allePreise.Where(p => p.Name.Contains(name)).FirstOrDefault(); + if (pausch != null) + { + var crlist = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(pausch.CostRatePeriods); + var cr = crlist.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney, datum); + if (cr != null && cr.CostRateValue.HasValue) + { + return cr.CostRateValue.Value; + } + } + return 0; + } + + private object GetLeistungsgruppe(decimal? approvedBEPerInterval) + { + // alle Leistungen werden in Stufen - sogenannten Leistungsgruppen abgerechnet - + // bei der QA/KA tragen sie die tatsächlich bewilligten Minuten ein, um zu wissen wie viel sie leisten müssen - Abrechnung braucht aber LG + decimal lg = 60; + if (approvedBEPerInterval == null || approvedBEPerInterval.Value < 91) + { + lg = 60; + } + else if (approvedBEPerInterval.Value < 151) + { + lg = 120; + } + else if (approvedBEPerInterval.Value < 211) + { + lg = 180; + } + else if (approvedBEPerInterval.Value < 271) + { + lg = 240; + } + else if (approvedBEPerInterval.Value < 391) + { + lg = 330; + } + else if (approvedBEPerInterval.Value < 511) + { + lg = 450; + } + else if (approvedBEPerInterval.Value < 751) + { + lg = 630; + } + else if (approvedBEPerInterval.Value < 1051) + { + lg = 900; + } + + return lg; + } + + private object GetLeistungsgruppennummer(decimal LG) + { + string nr = "1"; + if (LG / 60 < 5) + { + nr = String.Format("{0}", Math.Round(LG / 60, 0, MidpointRounding.AwayFromZero)); + } + else if (LG == 330) + { + nr = "5"; + } + else if (LG == 450) + { + nr = "6"; + } + else if (LG == 630) + { + nr = "7"; + } + else if (LG == 900) + { + nr = "8"; + } + return nr; + } + } +} diff --git a/ReportImp/PflegedienstRahnFreitag/Invoicing/CustomInvoiceFactory.cs b/ReportImp/PflegedienstRahnFreitag/Invoicing/CustomInvoiceFactory.cs new file mode 100644 index 000000000..597f81548 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Invoicing/CustomInvoiceFactory.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using BeWo.Data.Entities; +using BeWo.Service.Invoicing; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; + +namespace PflegedienstRahnFreitag.Invoicing +{ + public class CustomInvoiceFactory : InvoiceFactory + { + public override InvoiceCreation CreateInvoiceCreator(string specificId, string tenant, Dictionary> supportConcepts2ServiceRecords) + { + return new CollectiveInvoiceCreation(); + } + } +} diff --git a/ReportImp/PflegedienstRahnFreitag/LogoQA.jpg b/ReportImp/PflegedienstRahnFreitag/LogoQA.jpg new file mode 100644 index 000000000..ed4cfc673 Binary files /dev/null and b/ReportImp/PflegedienstRahnFreitag/LogoQA.jpg differ diff --git a/ReportImp/PflegedienstRahnFreitag/PflegedienstRahnFreitag.csproj b/ReportImp/PflegedienstRahnFreitag/PflegedienstRahnFreitag.csproj new file mode 100644 index 000000000..3c2f76064 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/PflegedienstRahnFreitag.csproj @@ -0,0 +1,120 @@ + + + + + Debug + AnyCPU + {07F34D7C-B4A0-45E1-82BF-CD45BDB26A6E} + Library + Properties + PflegedienstRahnFreitag + 8743996874_Reports + v4.7.2 + 512 + + + + true + full + false + ..\..\CustomerDlls\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + ..\..\CustomerDlls\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + + + Component + + + ServiceInvoiceReport.cs + + + + + + + + + + {B0D73E3D-4AE7-4024-93A6-DB1F46D7CCEE} + Data + + + {40d8b312-ea64-49e3-a31a-5e57ed4d5654} + Report + + + {094331c3-ecee-4c89-bbfd-4c9ded89f0ef} + Service + + + {2f50b83d-a3f0-4ec4-979a-3f9b7e3d8ed4} + Shared + + + + + + + + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + ServiceInvoiceReport.cs + Designer + + + + \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Properties/AssemblyInfo.cs b/ReportImp/PflegedienstRahnFreitag/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..930888dd6 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die einer Assembly zugeordnet sind. +[assembly: AssemblyTitle("KundeXyz")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("KundeXyz")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly +// für COM-Komponenten unsichtbar. Wenn Sie auf einen Typ in dieser Assembly von +// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("c1fed668-adb9-47e0-b589-1389618e1b6e")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden, +// indem Sie "*" wie unten gezeigt eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/ReportImp/PflegedienstRahnFreitag/Properties/Resources.Designer.cs b/ReportImp/PflegedienstRahnFreitag/Properties/Resources.Designer.cs new file mode 100644 index 000000000..86801aff5 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.42000 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +namespace PflegedienstRahnFreitag.Properties { + using System; + + + /// + /// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + /// + // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert + // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. + // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen + // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PflegedienstRahnFreitag.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Ãœberschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + /// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ReportImp/PflegedienstRahnFreitag/Properties/Resources.resx b/ReportImp/PflegedienstRahnFreitag/Properties/Resources.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Properties/licenses.licx b/ReportImp/PflegedienstRahnFreitag/Properties/licenses.licx new file mode 100644 index 000000000..d59547a61 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Properties/licenses.licx @@ -0,0 +1 @@ +DevExpress.XtraReports.UI.XtraReport, DevExpress.XtraReports.v23.2, Version=23.2.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a diff --git a/ReportImp/PflegedienstRahnFreitag/Reporting/CustomMitarbeiterstundenkontoBerechnung.cs b/ReportImp/PflegedienstRahnFreitag/Reporting/CustomMitarbeiterstundenkontoBerechnung.cs new file mode 100644 index 000000000..8b32a2d7b --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Reporting/CustomMitarbeiterstundenkontoBerechnung.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using BeWo.Data.Entities; +using BeWo.Report.ReportObjects; + +using BS.Shared.Extensions; + + +namespace TemplateNeuKunde.Reporting +{ + public class CustomMitarbeiterstundenkontoBerechnung : MitarbeiterstundenkontoBerechnung + { + //Wenn halbe Feiertage konfiguriert werden sollen, muss diese Methode auch im VacationService einkommentiert werden + //public override decimal GetFeiertagsFaktor(DateTime start) + //{ + // if (start.Month == 12) + // { + // if (start.Day == 24 || start.Day == 31) + // { + // return 0.5m; + // } + // } + + // return base.GetFeiertagsFaktor(start); + //} + } +} diff --git a/ReportImp/PflegedienstRahnFreitag/Reporting/CustomReportCreator.cs b/ReportImp/PflegedienstRahnFreitag/Reporting/CustomReportCreator.cs new file mode 100644 index 000000000..3e064654a --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Reporting/CustomReportCreator.cs @@ -0,0 +1,201 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report; +using BeWo.Report.DefaultReports; +using BeWo.Report.ReportObjects; +using BeWo.Service.DCEntityMapper; +using DevExpress.XtraReports.UI; + +namespace TemplateNeuKunde.Reporting +{ + //public class CustomReportCreator : DefaultReportCreator + //{ + // //Einkommentiere für LWL Prüfliste, ZAD Nummer und ServiceDescription ergänzen + + + // //SQL Queries: + // //INSERT INTO `query` (`Oid`,`Tid`,`Type`,`Title`,`SQL`,`Notice`,`InsTs`,`InsUser`,`UdpUser`,`Version`,`IsActive`,`SystemEntryID`,`UserGroupOids`,`ReportTypeName`,`FileName`,`ExportTitle`) + // //VALUES(500,24,0,'LWL Quittierungsbelege','select \':Von\', \':Bis\', \':Klient/in\'','direct', NULL, NULL, NULL,1,1, NULL,'1', NULL, NULL, NULL); + + // //INSERT INTO `parameter` (`Oid`,`QueryOid`,`Tid`,`Name`,`Type`,`DbType`,`InsTs`,`InsUser`,`UdpUser`,`Version`,`IsActive`,`SystemEntryID`) VALUES(4,500,25,'Von_Bis',5, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + // //INSERT INTO `parameter` (`Oid`,`QueryOid`,`Tid`,`Name`,`Type`,`DbType`,`InsTs`,`InsUser`,`UdpUser`,`Version`,`IsActive`,`SystemEntryID`) VALUES(5,500,25,'Klient/in',2, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + + // //public override XtraReport CreateQueryReport(long queryOid, string queryReportId) + // //{ + // // if (queryOid == 500) + // // { + // // return CreateLwlPruefliste(CreateQueryRO(queryOid, queryReportId)); + + // // } + // // return base.CreateQueryReport(queryOid, queryReportId); + // //} + + // //private LwlPruefliste CreateLwlPruefliste(QueryRO queryRo) + // //{ + // // var liste = new LwlPruefliste(); + + // // if (queryRo.Rows.Count > 0) + // // { + // // DateTime start = DateTime.MaxValue; + // // DateTime end = DateTime.MinValue; + + // // if (queryRo.Rows[0].Field1 != null) + // // { + // // DateTime.TryParse(queryRo.Rows[0].Field1.ToString(), out start); + // // } + // // if (queryRo.Rows[0].Field2 != null) + // // { + // // DateTime.TryParse(queryRo.Rows[0].Field2.ToString(), out end); + // // } + // // long? customerOid = null; + // // if (queryRo.Rows[0].Field3.ToString() == "0") + // // { + // // var masterReport = new LwlPruefliste(); + // // //masterReport.CreateDocument(); + + // // var customerList = DAOFactory.GenericDAO.GetAllActive(); + // // var customerListOrd = customerList.OrderBy(c => c.Person.LastNameFirstName).ToList(); + // // foreach (var c in customerListOrd) + // // { + // // var ro = LwlPrueflisteRO.Create(start, end, "9011113", c.Oid); + // // if (ro.ServiceRecords != null && ro.ServiceRecords.Count > 0) + // // { + // // try + // // { + // // liste = new LwlPruefliste(); + // // liste.SetReportDataSource(ro); + // // liste.CreateDocument(); + // // masterReport.Pages.AddRange(liste.Pages); + // // } + // // catch + // // { + // // // ignore - z.B. kein Hilfeplan + // // } + // // } + // // } + // // return (LwlPruefliste)masterReport; + // // } + + // // if (queryRo.Rows[0].Field3 != null) + // // { + // // if (Int64.TryParse(queryRo.Rows[0].Field3.ToString(), out var oidOut)) + // // { + // // customerOid = oidOut; + // // } + // // var ro = LwlPrueflisteRO.Create(start, end, "9011113", customerOid); + // // liste.SetReportDataSource(ro); + // // return liste; + // // } + // // } + + // // return liste; + // //} + + + // //Einkommentiere für LWL 2. Seite mit Anhang für Budgetnachweise + // //public override XtraReport CreateSettlementReport(string dcId, long? invoiceBaseOid) + // //{ + // // return base.CreateSettlementReport(dcId, invoiceBaseOid, true); + // //} + + + // //public override XtraReport CreateServiceOverviewAllCustomersReport(int month, int year, long orgaOid, long empOid, long? serviceCategoryOid, int startDay, int endDay) + // //{ + // // List lROs = ServicesOverviewRO.Create(month, year, orgaOid, empOid, startDay, endDay); + + // // if (lROs.Count > 0) + // // { + + // // var rootReport = CreateServicesOverviewReportForRo(lROs[0], serviceCategoryOid); + // // rootReport.CreateDocument(); + + // // for (int i = 1; i < lROs.Count; i++) + // // { + // // var lNext = CreateServicesOverviewReportForRo(lROs[i], serviceCategoryOid); + // // lNext.CreateDocument(); + // // rootReport.Pages.AddRange(lNext.Pages); + // // } + + // // return rootReport; + // // } + // // return new XtraReport(); + // //} + + // //public override XtraReport CreateServiceOverviewSingleCustomerReport(long customerOid, int month, int year, long orgaOid, long empOid, long? serviceCategoryOid, int startDay, int endDay) + // //{ + // // var ro = ServicesOverviewRO.Create(customerOid, month, year, false, orgaOid, empOid, startDay, endDay, serviceCategoryOid); + // // return CreateServicesOverviewReportForRo(ro, serviceCategoryOid); + // //} + // //public override XtraReport CreateServiceOverviewReportForCustomers(IList customerOids, int month, int year, long? orgaOid, long? empOid, long? serviceCategoryOid, int startDay, int endDay, bool nurFehlende) + // //{ + // // var roList = new List(); + + // // foreach (var coid in customerOids) + // // { + // // var ro = ServicesOverviewRO.Create(coid, month, year, true, orgaOid ?? 0, empOid ?? 0, startDay, endDay, serviceCategoryOid); + // // if (ro != null) + // // { + // // roList.Add(ro); + // // } + // // } + + // // if (roList.Count > 0) + // // { + + // // var rootReport = CreateServicesOverviewReportForRo(roList[0], serviceCategoryOid); + // // rootReport.CreateDocument(); + + // // for (int i = 1; i < roList.Count; i++) + // // { + // // var lNext = CreateServicesOverviewReportForRo(roList[i], serviceCategoryOid); + // // lNext.CreateDocument(); + // // rootReport.Pages.AddRange(lNext.Pages); + // // } + + // // return rootReport; + // // } + // // return new XtraReport(); + + // //} + //public override XtraReport CreateReportForServicesOverviewRo(ServicesOverviewRO ro, String reportId) + //{ + // return CreateServicesOverviewReportForRo(ro, null); + //} + + // //private XtraReport CreateServicesOverviewReportForRo(ServicesOverviewRO ro, long? serviceCategoryOid) + // //{ + // // IBeWoReport report = null; + // // String kt = ""; + // // if (!String.IsNullOrWhiteSpace(ro.Costbearer)) + // // kt = ro.Costbearer.Trim(); + + // // String function = ""; + // // if (ro.CostBearer2SupportConceptList != null) + // // { + // // foreach (var c2s in ro.CostBearer2SupportConceptList) + // // { + // // if (c2s.CostBearer.Organisation.Function != null && !String.IsNullOrWhiteSpace(ro.Costbearer) && c2s.CostBearer.Organisation.Name == ro.Costbearer) + // // function = c2s.CostBearer.Organisation.Function.Value; + // // } + // // } + + // // if (kt == "Kreisverwaltung Mainz-Bingen") + // // report = new AlzeyTeilhabe.StundenzettelBi2(); + + // // if (report == null && function == "Kostenträger Soziotherapie") + // // report = new StundenzettelSoziotherapie(); + + // // if (report == null) + // // report = new AlzeyTeilhabe.StundenzettelWo(); + + // // report.SetReportDataSource(ro); + + // // return report as XtraReport; + // //} + + //} +} diff --git a/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.Designer.cs b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.Designer.cs new file mode 100644 index 000000000..0258e9699 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.Designer.cs @@ -0,0 +1,947 @@ +using BeWo.Report.ReportObjects; +namespace PflegedienstRahnFreitag +{ + partial class ServiceInvoiceReport + { + /// + /// 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(ServiceInvoiceReport)); + 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.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.ruleRateFactorNull = new DevExpress.XtraReports.UI.FormattingRule(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.xrPictureBox1 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.xrRichText2 = new DevExpress.XtraReports.UI.XRRichText(); + this.xrRichText1 = new DevExpress.XtraReports.UI.XRRichText(); + this.Page1 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel7 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel12 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblAdresse = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable2 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow2 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow5 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell13 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow4 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell11 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow3 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell8 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow1 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow6 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow8 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail1 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable5 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow23 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell32 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell37 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell33 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell36 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell34 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.DetailReport2 = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail3 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable6 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow25 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell40 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell42 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell44 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell45 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell47 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupFooter1 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrLabel29 = new DevExpress.XtraReports.UI.XRLabel(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + // + // Detail + // + this.Detail.HeightF = 0F; + this.Detail.Name = "Detail"; + this.Detail.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // ReportHeader + // + this.ReportHeader.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.ReportHeader.HeightF = 0F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // ruleRateFactorNull + // + this.ruleRateFactorNull.Condition = "[RateFactorText2] == ?"; + this.ruleRateFactorNull.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.ruleRateFactorNull.Name = "ruleRateFactorNull"; + // + // topMarginBand1 + // + this.topMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrPictureBox1}); + this.topMarginBand1.HeightF = 201.6667F; + this.topMarginBand1.Name = "topMarginBand1"; + // + // xrPictureBox1 + // + this.xrPictureBox1.ImageAlignment = DevExpress.XtraPrinting.ImageAlignment.MiddleCenter; + this.xrPictureBox1.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox1.ImageSource")); + this.xrPictureBox1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrPictureBox1.Name = "xrPictureBox1"; + this.xrPictureBox1.SizeF = new System.Drawing.SizeF(826.6666F, 201.6667F); + this.xrPictureBox1.Sizing = DevExpress.XtraPrinting.ImageSizeMode.AutoSize; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrRichText2, + this.xrRichText1}); + this.bottomMarginBand1.HeightF = 120.0835F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // xrRichText2 + // + this.xrRichText2.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.xrRichText2.LocationFloat = new DevExpress.Utils.PointFloat(400.5015F, 9.999974F); + this.xrRichText2.Name = "xrRichText2"; + this.xrRichText2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrRichText2.SerializableRtfString = resources.GetString("xrRichText2.SerializableRtfString"); + this.xrRichText2.SizeF = new System.Drawing.SizeF(384.0835F, 71.95835F); + // + // xrRichText1 + // + this.xrRichText1.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.xrRichText1.LocationFloat = new DevExpress.Utils.PointFloat(52.6619F, 9.999974F); + this.xrRichText1.Name = "xrRichText1"; + this.xrRichText1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrRichText1.SerializableRtfString = resources.GetString("xrRichText1.SerializableRtfString"); + this.xrRichText1.SizeF = new System.Drawing.SizeF(332.0465F, 71.95835F); + // + // Page1 + // + this.Page1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel6, + this.xrLabel7, + this.xrLabel11, + this.xrLabel12, + this.lblAdresse, + this.xrLabel5, + this.xrTable2}); + this.Page1.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.Page1.HeightF = 293.6666F; + this.Page1.Name = "Page1"; + this.Page1.StylePriority.UseFont = false; + // + // xrLabel6 + // + this.xrLabel6.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceDate")}); + this.xrLabel6.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(644.25F, 261.7914F); + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(140.3333F, 20F); + this.xrLabel6.StylePriority.UseFont = false; + this.xrLabel6.StylePriority.UseTextAlignment = false; + this.xrLabel6.Text = "xrLabel8"; + this.xrLabel6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrLabel6.TextFormatString = "{0:dd.MM.yyyy}"; + // + // xrLabel7 + // + this.xrLabel7.BackColor = System.Drawing.Color.Transparent; + this.xrLabel7.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right))); + this.xrLabel7.CanShrink = true; + this.xrLabel7.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel7.LocationFloat = new DevExpress.Utils.PointFloat(208.6667F, 241.7914F); + this.xrLabel7.Name = "xrLabel7"; + this.xrLabel7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel7.SizeF = new System.Drawing.SizeF(154.875F, 20F); + this.xrLabel7.StylePriority.UseBackColor = false; + this.xrLabel7.StylePriority.UseBorders = false; + this.xrLabel7.StylePriority.UseFont = false; + this.xrLabel7.Text = "Bitte immer angeben"; + this.xrLabel7.WordWrap = false; + // + // xrLabel11 + // + this.xrLabel11.BackColor = System.Drawing.Color.Transparent; + this.xrLabel11.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top))); + this.xrLabel11.CanShrink = true; + this.xrLabel11.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 241.7914F); + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(140.9584F, 20F); + this.xrLabel11.StylePriority.UseBackColor = false; + this.xrLabel11.StylePriority.UseBorders = false; + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.StylePriority.UseTextAlignment = false; + this.xrLabel11.Text = "[InvoiceNumber]"; + this.xrLabel11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrLabel11.WordWrap = false; + // + // xrLabel12 + // + this.xrLabel12.BackColor = System.Drawing.Color.Transparent; + this.xrLabel12.CanShrink = true; + this.xrLabel12.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel12.LocationFloat = new DevExpress.Utils.PointFloat(524.0416F, 263.6666F); + this.xrLabel12.Name = "xrLabel12"; + this.xrLabel12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel12.SizeF = new System.Drawing.SizeF(93.58344F, 20.00003F); + this.xrLabel12.StylePriority.UseBackColor = false; + this.xrLabel12.StylePriority.UseFont = false; + this.xrLabel12.Text = "Datum"; + this.xrLabel12.WordWrap = false; + // + // lblAdresse + // + this.lblAdresse.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.lblAdresse.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 83.12498F); + this.lblAdresse.Multiline = true; + this.lblAdresse.Name = "lblAdresse"; + this.lblAdresse.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblAdresse.SizeF = new System.Drawing.SizeF(317F, 111.5F); + this.lblAdresse.StylePriority.UseFont = false; + this.lblAdresse.Text = "[RecipientOrganisation]\r\n[RecipientContactPerson]\r\n[RecipientStreet]\r\n[RecipientP" + + "ostCodeAndTown]"; + // + // xrLabel5 + // + this.xrLabel5.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel5.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 261.7914F); + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(295.8333F, 17F); + this.xrLabel5.StylePriority.UseBorders = false; + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "Zeitraum [AccountingPeriodEnd!MMMM yyyy]"; + // + // xrTable2 + // + this.xrTable2.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTable2.LocationFloat = new DevExpress.Utils.PointFloat(481.7917F, 13.12501F); + this.xrTable2.Name = "xrTable2"; + this.xrTable2.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow2, + this.xrTableRow5, + this.xrTableRow4, + this.xrTableRow3, + this.xrTableRow1, + this.xrTableRow6, + this.xrTableRow8}); + this.xrTable2.SizeF = new System.Drawing.SizeF(302.7917F, 140F); + this.xrTable2.StylePriority.UseFont = false; + this.xrTable2.StylePriority.UseTextAlignment = false; + this.xrTable2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrTableRow2 + // + this.xrTableRow2.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell4}); + this.xrTableRow2.Name = "xrTableRow2"; + this.xrTableRow2.Weight = 0.098575570463507553D; + // + // xrTableCell4 + // + this.xrTableCell4.CanShrink = true; + this.xrTableCell4.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell4.Name = "xrTableCell4"; + this.xrTableCell4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell4.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell4.StylePriority.UseFont = false; + this.xrTableCell4.StylePriority.UseTextAlignment = false; + this.xrTableCell4.Text = "Pflegedienst Rahn und Freitag "; + this.xrTableCell4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell4.Weight = 1D; + // + // xrTableRow5 + // + this.xrTableRow5.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell13}); + this.xrTableRow5.Name = "xrTableRow5"; + this.xrTableRow5.Weight = 0.098575570463507525D; + // + // xrTableCell13 + // + this.xrTableCell13.CanShrink = true; + this.xrTableCell13.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell13.Name = "xrTableCell13"; + this.xrTableCell13.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell13.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell13.StylePriority.UseFont = false; + this.xrTableCell13.StylePriority.UseTextAlignment = false; + this.xrTableCell13.Text = "Abt. Qualifizierte Assistenz"; + this.xrTableCell13.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell13.Weight = 1D; + // + // xrTableRow4 + // + this.xrTableRow4.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell11}); + this.xrTableRow4.Name = "xrTableRow4"; + this.xrTableRow4.Weight = 0.098575570463507511D; + // + // xrTableCell11 + // + this.xrTableCell11.CanShrink = true; + this.xrTableCell11.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell11.Name = "xrTableCell11"; + this.xrTableCell11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell11.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell11.StylePriority.UseFont = false; + this.xrTableCell11.StylePriority.UseTextAlignment = false; + this.xrTableCell11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell11.Weight = 1D; + // + // xrTableRow3 + // + this.xrTableRow3.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell8}); + this.xrTableRow3.Name = "xrTableRow3"; + this.xrTableRow3.Weight = 0.0985755672652636D; + // + // xrTableCell8 + // + this.xrTableCell8.CanShrink = true; + this.xrTableCell8.Font = new DevExpress.Drawing.DXFont("ARial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell8.Name = "xrTableCell8"; + this.xrTableCell8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell8.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell8.StylePriority.UseFont = false; + this.xrTableCell8.StylePriority.UseTextAlignment = false; + this.xrTableCell8.Text = "Leitung Eingliederungshilfe: Andreas Bayer"; + this.xrTableCell8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell8.Weight = 1D; + // + // xrTableRow1 + // + this.xrTableRow1.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell1}); + this.xrTableRow1.Name = "xrTableRow1"; + this.xrTableRow1.Weight = 0.098575570366591023D; + // + // xrTableCell1 + // + this.xrTableCell1.CanShrink = true; + this.xrTableCell1.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell1.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell1.StylePriority.UseFont = false; + this.xrTableCell1.StylePriority.UseTextAlignment = false; + this.xrTableCell1.Text = "a.bayer@rahn-und-freitag.de"; + this.xrTableCell1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell1.Weight = 1D; + // + // xrTableRow6 + // + this.xrTableRow6.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell2}); + this.xrTableRow6.Name = "xrTableRow6"; + this.xrTableRow6.Weight = 0.09857557036659112D; + // + // xrTableCell2 + // + this.xrTableCell2.CanShrink = true; + this.xrTableCell2.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell2.Name = "xrTableCell2"; + this.xrTableCell2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell2.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell2.StylePriority.UseFont = false; + this.xrTableCell2.StylePriority.UseTextAlignment = false; + this.xrTableCell2.Text = "Qualifizierte Assistenz für den "; + this.xrTableCell2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell2.Weight = 1D; + // + // xrTableRow8 + // + this.xrTableRow8.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell5}); + this.xrTableRow8.Name = "xrTableRow8"; + this.xrTableRow8.Weight = 0.098575570463507484D; + // + // xrTableCell5 + // + this.xrTableCell5.Font = new DevExpress.Drawing.DXFont("ARial", 10F); + this.xrTableCell5.Name = "xrTableCell5"; + this.xrTableCell5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell5.StylePriority.UseFont = false; + this.xrTableCell5.StylePriority.UseTextAlignment = false; + this.xrTableCell5.Text = "Den Landkreis Giessen und den Lahn Dill Kreis "; + this.xrTableCell5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell5.Weight = 1D; + // + // DetailReport + // + this.DetailReport.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail1, + this.DetailReport2}); + this.DetailReport.DataMember = "ServiceInvoicePeriods"; + this.DetailReport.DataSource = this.bindingSource1; + this.DetailReport.Level = 0; + this.DetailReport.Name = "DetailReport"; + // + // Detail1 + // + this.Detail1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel8, + this.xrLabel4, + this.xrLabel2, + this.xrTable5}); + this.Detail1.HeightF = 65.00002F; + this.Detail1.Name = "Detail1"; + // + // xrLabel8 + // + this.xrLabel8.BackColor = System.Drawing.Color.Transparent; + this.xrLabel8.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right))); + this.xrLabel8.CanShrink = true; + this.xrLabel8.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(524.0416F, 0F); + this.xrLabel8.Multiline = true; + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(260.5418F, 20F); + this.xrLabel8.StylePriority.UseBackColor = false; + this.xrLabel8.StylePriority.UseBorders = false; + this.xrLabel8.StylePriority.UseFont = false; + this.xrLabel8.StylePriority.UseTextAlignment = false; + this.xrLabel8.Text = "Aktenzeichen [CostBearer2SupportConcept.CustomerReferenceNumber]"; + this.xrLabel8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrLabel8.WordWrap = false; + // + // xrLabel4 + // + this.xrLabel4.BackColor = System.Drawing.Color.Transparent; + this.xrLabel4.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top))); + this.xrLabel4.CanShrink = true; + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 0F); + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(298.713F, 20F); + this.xrLabel4.StylePriority.UseBackColor = false; + this.xrLabel4.StylePriority.UseBorders = false; + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.StylePriority.UseTextAlignment = false; + this.xrLabel4.Text = "Name [Customer.LastNameFirstName]"; + this.xrLabel4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrLabel4.WordWrap = false; + // + // xrLabel2 + // + this.xrLabel2.BackColor = System.Drawing.Color.Transparent; + this.xrLabel2.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top))); + this.xrLabel2.CanShrink = true; + this.xrLabel2.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(366.4214F, 0F); + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(157.6202F, 20F); + this.xrLabel2.StylePriority.UseBackColor = false; + this.xrLabel2.StylePriority.UseBorders = false; + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "Geb. Dat [Customer.DateOfBirth!dd.MM.yyyy]"; + this.xrLabel2.WordWrap = false; + // + // xrTable5 + // + this.xrTable5.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTable5.LocationFloat = new DevExpress.Utils.PointFloat(67.7084F, 20.00001F); + this.xrTable5.Name = "xrTable5"; + this.xrTable5.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow23}); + this.xrTable5.SizeF = new System.Drawing.SizeF(716.8751F, 45F); + this.xrTable5.StylePriority.UseFont = false; + // + // xrTableRow23 + // + this.xrTableRow23.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell32, + this.xrTableCell37, + this.xrTableCell33, + this.xrTableCell36, + this.xrTableCell34, + this.xrTableCell3}); + this.xrTableRow23.Name = "xrTableRow23"; + this.xrTableRow23.Weight = 1.8D; + // + // xrTableCell32 + // + this.xrTableCell32.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell32.BorderColor = System.Drawing.Color.Black; + this.xrTableCell32.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell32.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell32.Name = "xrTableCell32"; + this.xrTableCell32.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell32.StylePriority.UseBackColor = false; + this.xrTableCell32.StylePriority.UseBorderColor = false; + this.xrTableCell32.StylePriority.UseBorders = false; + this.xrTableCell32.StylePriority.UseFont = false; + this.xrTableCell32.StylePriority.UsePadding = false; + this.xrTableCell32.StylePriority.UseTextAlignment = false; + this.xrTableCell32.Text = "Leistungsbeschreibung"; + this.xrTableCell32.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomLeft; + this.xrTableCell32.Weight = 1.0169865988847711D; + // + // xrTableCell37 + // + this.xrTableCell37.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell37.BorderColor = System.Drawing.Color.Black; + this.xrTableCell37.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell37.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell37.Name = "xrTableCell37"; + this.xrTableCell37.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell37.StylePriority.UseBackColor = false; + this.xrTableCell37.StylePriority.UseBorderColor = false; + this.xrTableCell37.StylePriority.UseBorders = false; + this.xrTableCell37.StylePriority.UseFont = false; + this.xrTableCell37.StylePriority.UsePadding = false; + this.xrTableCell37.StylePriority.UseTextAlignment = false; + this.xrTableCell37.Text = "Von"; + this.xrTableCell37.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomRight; + this.xrTableCell37.Weight = 0.30670489370990361D; + // + // xrTableCell33 + // + this.xrTableCell33.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell33.BorderColor = System.Drawing.Color.Black; + this.xrTableCell33.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell33.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell33.Name = "xrTableCell33"; + this.xrTableCell33.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell33.StylePriority.UseBackColor = false; + this.xrTableCell33.StylePriority.UseBorderColor = false; + this.xrTableCell33.StylePriority.UseBorders = false; + this.xrTableCell33.StylePriority.UseFont = false; + this.xrTableCell33.StylePriority.UsePadding = false; + this.xrTableCell33.StylePriority.UseTextAlignment = false; + this.xrTableCell33.Text = "Bis"; + this.xrTableCell33.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomRight; + this.xrTableCell33.Weight = 0.31367913542418036D; + // + // xrTableCell36 + // + this.xrTableCell36.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell36.BorderColor = System.Drawing.Color.Black; + this.xrTableCell36.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell36.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell36.Name = "xrTableCell36"; + this.xrTableCell36.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell36.StylePriority.UseBackColor = false; + this.xrTableCell36.StylePriority.UseBorderColor = false; + this.xrTableCell36.StylePriority.UseBorders = false; + this.xrTableCell36.StylePriority.UseFont = false; + this.xrTableCell36.StylePriority.UsePadding = false; + this.xrTableCell36.StylePriority.UseTextAlignment = false; + this.xrTableCell36.Text = "Einzelpreis"; + this.xrTableCell36.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomRight; + this.xrTableCell36.Weight = 0.38478541659829257D; + // + // xrTableCell34 + // + this.xrTableCell34.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell34.BorderColor = System.Drawing.Color.Black; + this.xrTableCell34.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell34.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell34.Name = "xrTableCell34"; + this.xrTableCell34.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell34.StylePriority.UseBackColor = false; + this.xrTableCell34.StylePriority.UseBorderColor = false; + this.xrTableCell34.StylePriority.UseBorders = false; + this.xrTableCell34.StylePriority.UseFont = false; + this.xrTableCell34.StylePriority.UsePadding = false; + this.xrTableCell34.StylePriority.UseTextAlignment = false; + this.xrTableCell34.Text = "Anzahl"; + this.xrTableCell34.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomRight; + this.xrTableCell34.Weight = 0.41469765757622212D; + // + // xrTableCell3 + // + this.xrTableCell3.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell3.BorderColor = System.Drawing.Color.Black; + this.xrTableCell3.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell3.Font = new DevExpress.Drawing.DXFont("arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell3.Multiline = true; + this.xrTableCell3.Name = "xrTableCell3"; + this.xrTableCell3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell3.StylePriority.UseBackColor = false; + this.xrTableCell3.StylePriority.UseBorderColor = false; + this.xrTableCell3.StylePriority.UseBorders = false; + this.xrTableCell3.StylePriority.UseFont = false; + this.xrTableCell3.StylePriority.UsePadding = false; + this.xrTableCell3.StylePriority.UseTextAlignment = false; + this.xrTableCell3.Text = "Gesamtpreis"; + this.xrTableCell3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomRight; + this.xrTableCell3.Weight = 0.739845420457248D; + // + // DetailReport2 + // + this.DetailReport2.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail3, + this.GroupFooter1}); + this.DetailReport2.DataMember = "ServiceInvoicePeriods.ServiceInvoiceItems"; + this.DetailReport2.DataSource = this.bindingSource1; + this.DetailReport2.Level = 0; + this.DetailReport2.Name = "DetailReport2"; + // + // Detail3 + // + this.Detail3.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable6}); + this.Detail3.HeightF = 20F; + this.Detail3.Name = "Detail3"; + // + // xrTable6 + // + this.xrTable6.Font = new DevExpress.Drawing.DXFont("Verdana", 8.25F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTable6.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 0F); + this.xrTable6.Name = "xrTable6"; + this.xrTable6.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow25}); + this.xrTable6.SizeF = new System.Drawing.SizeF(716.8751F, 20F); + this.xrTable6.StylePriority.UseFont = false; + // + // xrTableRow25 + // + this.xrTableRow25.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell40, + this.xrTableCell42, + this.xrTableCell6, + this.xrTableCell44, + this.xrTableCell45, + this.xrTableCell47}); + this.xrTableRow25.Name = "xrTableRow25"; + this.xrTableRow25.Weight = 0.8D; + // + // xrTableCell40 + // + this.xrTableCell40.BorderColor = System.Drawing.Color.Black; + this.xrTableCell40.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell40.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.ServiceDescription")}); + this.xrTableCell40.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell40.Name = "xrTableCell40"; + this.xrTableCell40.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell40.StylePriority.UseBorderColor = false; + this.xrTableCell40.StylePriority.UseBorders = false; + this.xrTableCell40.StylePriority.UseFont = false; + this.xrTableCell40.StylePriority.UsePadding = false; + this.xrTableCell40.StylePriority.UseTextAlignment = false; + this.xrTableCell40.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell40.TextFormatString = "{0:MM.yyyy}"; + this.xrTableCell40.Weight = 1.0524276737505134D; + // + // xrTableCell42 + // + this.xrTableCell42.BorderColor = System.Drawing.Color.Black; + this.xrTableCell42.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell42.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.AccountingPeriodStart")}); + this.xrTableCell42.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell42.Name = "xrTableCell42"; + this.xrTableCell42.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell42.StylePriority.UseBorderColor = false; + this.xrTableCell42.StylePriority.UseBorders = false; + this.xrTableCell42.StylePriority.UseFont = false; + this.xrTableCell42.StylePriority.UsePadding = false; + this.xrTableCell42.StylePriority.UseTextAlignment = false; + this.xrTableCell42.Text = "Betreuung"; + this.xrTableCell42.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell42.TextFormatString = "{0:dd.MM.yy}"; + this.xrTableCell42.Weight = 0.31739276492761159D; + // + // xrTableCell6 + // + this.xrTableCell6.BorderColor = System.Drawing.Color.Black; + this.xrTableCell6.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell6.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.AccountingPeriodEnd")}); + this.xrTableCell6.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell6.Multiline = true; + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + 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 = "xrTableCell6"; + this.xrTableCell6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell6.TextFormatString = "{0:dd.MM.yy}"; + this.xrTableCell6.Weight = 0.3246110237324154D; + // + // xrTableCell44 + // + this.xrTableCell44.BorderColor = System.Drawing.Color.Black; + this.xrTableCell44.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell44.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.HourlyRate")}); + this.xrTableCell44.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell44.Name = "xrTableCell44"; + this.xrTableCell44.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell44.StylePriority.UseBorderColor = false; + this.xrTableCell44.StylePriority.UseBorders = false; + this.xrTableCell44.StylePriority.UseFont = false; + this.xrTableCell44.StylePriority.UsePadding = false; + this.xrTableCell44.StylePriority.UseTextAlignment = false; + this.xrTableCell44.Text = "xrTableCell44"; + this.xrTableCell44.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell44.TextFormatString = "{0:c2}"; + this.xrTableCell44.Weight = 0.39819450999665218D; + // + // xrTableCell45 + // + this.xrTableCell45.BorderColor = System.Drawing.Color.Black; + this.xrTableCell45.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell45.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.Hours", "{0:0.00}")}); + this.xrTableCell45.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell45.Name = "xrTableCell45"; + this.xrTableCell45.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell45.StylePriority.UseBorderColor = false; + this.xrTableCell45.StylePriority.UseBorders = false; + this.xrTableCell45.StylePriority.UseFont = false; + this.xrTableCell45.StylePriority.UsePadding = false; + this.xrTableCell45.StylePriority.UseTextAlignment = false; + this.xrTableCell45.Text = "xrTableCell45"; + this.xrTableCell45.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell45.Weight = 0.42914931788975635D; + // + // xrTableCell47 + // + this.xrTableCell47.BorderColor = System.Drawing.Color.Black; + this.xrTableCell47.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell47.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.NetAmount")}); + this.xrTableCell47.Font = new DevExpress.Drawing.DXFont("arial", 10F); + this.xrTableCell47.Name = "xrTableCell47"; + this.xrTableCell47.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell47.StylePriority.UseBorderColor = false; + this.xrTableCell47.StylePriority.UseBorders = false; + this.xrTableCell47.StylePriority.UseFont = false; + this.xrTableCell47.StylePriority.UsePadding = false; + this.xrTableCell47.StylePriority.UseTextAlignment = false; + this.xrTableCell47.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell47.TextFormatString = "{0:c2}"; + this.xrTableCell47.Weight = 0.76562792463170926D; + // + // GroupFooter1 + // + this.GroupFooter1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel29}); + this.GroupFooter1.HeightF = 65.7917F; + this.GroupFooter1.Name = "GroupFooter1"; + // + // xrLabel29 + // + this.xrLabel29.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel29.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.NetAmount")}); + this.xrLabel29.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel29.LocationFloat = new DevExpress.Utils.PointFloat(617.625F, 0F); + this.xrLabel29.Name = "xrLabel29"; + this.xrLabel29.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel29.SizeF = new System.Drawing.SizeF(166.96F, 20F); + this.xrLabel29.StylePriority.UseBorders = false; + this.xrLabel29.StylePriority.UseFont = false; + this.xrLabel29.StylePriority.UseTextAlignment = false; + xrSummary1.Running = DevExpress.XtraReports.UI.SummaryRunning.Group; + this.xrLabel29.Summary = xrSummary1; + this.xrLabel29.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrLabel29.TextFormatString = "{0:c2}"; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.ServiceInvoiceRO); + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel1, + this.xrLabel3}); + this.ReportFooter.Name = "ReportFooter"; + // + // xrLabel1 + // + this.xrLabel1.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel1.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "GrossClaim")}); + this.xrLabel1.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(616.4183F, 0F); + this.xrLabel1.Name = "xrLabel1"; + this.xrLabel1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel1.SizeF = new System.Drawing.SizeF(168.1649F, 20.00001F); + this.xrLabel1.StylePriority.UseBorders = false; + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.StylePriority.UseTextAlignment = false; + this.xrLabel1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel3 + // + this.xrLabel3.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel3.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(67.70834F, 0F); + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(548.71F, 20F); + this.xrLabel3.StylePriority.UseBorders = false; + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Fälliger Betrag:"; + // + // ServiceInvoiceReport + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.topMarginBand1, + this.bottomMarginBand1, + this.Page1, + this.DetailReport, + this.ReportFooter}); + this.DataSource = this.bindingSource1; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleRateFactorNull}); + this.Margins = new DevExpress.Drawing.DXMargins(0F, 0F, 201.6667F, 120.0835F); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.Version = "23.2"; + xrWatermark1.Id = "Watermark1"; + this.Watermarks.Add(xrWatermark1); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + + } + + + private DevExpress.XtraReports.UI.DetailBand Detail; + private System.Windows.Forms.BindingSource bindingSource1; + private DevExpress.XtraReports.UI.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.FormattingRule ruleRateFactorNull; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.GroupHeaderBand Page1; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.XRTable xrTable2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell13; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell11; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell8; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow8; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport; + private DevExpress.XtraReports.UI.DetailBand Detail1; + private DevExpress.XtraReports.UI.XRTable xrTable5; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow23; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell32; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell37; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell33; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell36; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell34; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport2; + private DevExpress.XtraReports.UI.DetailBand Detail3; + private DevExpress.XtraReports.UI.XRTable xrTable6; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow25; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell40; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell42; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell44; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell45; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell47; + private DevExpress.XtraReports.UI.XRLabel lblAdresse; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter1; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + private DevExpress.XtraReports.UI.XRLabel xrLabel7; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRLabel xrLabel12; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.XRLabel xrLabel29; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRRichText xrRichText2; + private DevExpress.XtraReports.UI.XRRichText xrRichText1; + } +} diff --git a/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.cs b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.cs new file mode 100644 index 000000000..cb81e3594 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.cs @@ -0,0 +1,99 @@ +using System; +using System.Linq; +using System.Text; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report; +using BeWo.Report.ReportObjects; +using BeWo.Service.DCEntityMapper; +using BS.Shared; +using BS.Shared.Extensions; +using DevExpress.XtraReports.UI; + +namespace PflegedienstRahnFreitag +{ + public partial class ServiceInvoiceReport : XtraReport, IBeWoReport + { + public ServiceInvoiceReport() + { + this.InitializeComponent(); + } + + public void SetReportDataSource(ServiceInvoiceRO pRO) + { + SetzeAdresse(pRO); + if (pRO.ServiceInvoicePeriods != null && pRO.ServiceInvoicePeriods.Count > 0) + { + pRO.ServiceInvoicePeriods = pRO.ServiceInvoicePeriods.OrderBy(s => s.Customer.LastNameFirstName).ToList(); + var listLength = pRO.ServiceInvoicePeriods.Count; + for (int i = listLength - 1; i >= 1; i--) + { + var sip = pRO.ServiceInvoicePeriods[i]; + var sipNew = pRO.ServiceInvoicePeriods[i - 1]; + if (sip.Customer.LastNameFirstName == sipNew.Customer.LastNameFirstName && + sip.CostBearer2SupportConcept.Oid == sipNew.CostBearer2SupportConcept.Oid + && sip.ServiceInvoiceItems != null && sip.ServiceInvoiceItems.Count > 0 + && sipNew.ServiceInvoiceItems != null && sipNew.ServiceInvoiceItems.Count > 0) + { + sipNew.ServiceInvoiceItems.AddRange(sip.ServiceInvoiceItems); + //sipNew.Claim += sip.Claim; + pRO.ServiceInvoicePeriods.Remove(sip); + } + } + } + + //SetzeRegion(pRO); + //SetzeBetreuungsart(pRO); + //SetzeDebitornummer(pRO); + + this.bindingSource1.DataSource = pRO; + } + + //private void SetzeDebitornummer(ServiceInvoiceRO pRO) + //{ + // foreach (var sip in pRO.ServiceInvoicePeriods) + // { + // if (sip.Customer != null) + // { + // var cust = DAOFactory.GenericDAO.GetByID(sip.Customer.CustomerOid); + // if (!cust.DebitorNumber.IsNullOrEmpty()) + // lblDebitorNummer.Text = cust.DebitorNumber; + // } + // } + //} + + private void SetzeAdresse(ServiceInvoiceRO pRO) + { + StringBuilder sb = new StringBuilder(); + if (!String.IsNullOrEmpty(pRO.RecipientOrganisation) && pRO.RecipientOrganisation.ToLower() != "selbstzahler") + { + sb.AppendLine(pRO.RecipientOrganisation); + } + //if (!String.IsNullOrEmpty(pRO.RecipientAddressLine1)) + //{ + // sb.AppendLine(pRO.RecipientAddressLine1); + //} + if (!String.IsNullOrEmpty(pRO.RecipientContactPerson)) + { + sb.AppendLine(pRO.RecipientContactPerson); + } + if (!String.IsNullOrEmpty(pRO.RecipientDivision) && !String.IsNullOrEmpty(pRO.RecipientOrganisation) && pRO.RecipientOrganisation.ToLower() != "selbstzahler") + { + sb.AppendLine(pRO.RecipientDivision); + } + if (!String.IsNullOrEmpty(pRO.RecipientPoBox)) + { + sb.AppendLine(pRO.RecipientPoBox); + } + else if (!String.IsNullOrEmpty(pRO.RecipientStreet)) + { + sb.AppendLine(pRO.RecipientStreet); + } + if (!String.IsNullOrEmpty(pRO.RecipientPostCodeAndTown)) + { + sb.AppendLine(pRO.RecipientPostCodeAndTown); + } + lblAdresse.Text = sb.ToString(); + } + } +} \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.resx b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.resx new file mode 100644 index 000000000..59f8c966b --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Reporting/ServiceInvoiceReport.resx @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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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 + + + ewBcAHIAdABmADEAXABkAGUAZgBmADAAewBcAGYAbwBuAHQAdABiAGwAewBcAGYAMAAgAEMAYQBsAGkAYgByAGkAOwB9AHsAXABmADEAIABUAGkAbQBlAHMAIABOAGUAdwAgAFIAbwBtAGEAbgA7AH0AewBcAGYAMgAgAFYAZQByAGQAYQBuAGEAOwB9AH0AewBcAGMAbwBsAG8AcgB0AGIAbAAgADsAXAByAGUAZAAwAFwAZwByAGUAZQBuADAAXABiAGwAdQBlADAAIAA7AFwAcgBlAGQAMABcAGcAcgBlAGUAbgAwAFwAYgBsAHUAZQAyADUANQAgADsAfQB7AFwAKgBcAGQAZQBmAGMAaABwACAAXABmADEAXABmAHMAMgA0AH0AewBcACoAXABkAGUAZgBwAGEAcAAgAFwAdwBpAGQAYwB0AGwAcABhAHIAfQB7AFwAcwB0AHkAbABlAHMAaABlAGUAdAAgAHsAXABxAGwAXABmADEAXABmAHMAMgA0ACAATgBvAHIAbQBhAGwAOwB9AHsAXAAqAFwAYwBzADEAXABmADEAXABmAHMAMgA0AFwAYwBmADEAIABEAGUAZgBhAHUAbAB0ACAAUABhAHIAYQBnAHIAYQBwAGgAIABGAG8AbgB0ADsAfQB7AFwAKgBcAGMAcwAyAFwAcwBiAGEAcwBlAGQAbwBuADEAXABmADEAXABmAHMAMgA0AFwAYwBmADEAIABMAGkAbgBlACAATgB1AG0AYgBlAHIAOwB9AHsAXAAqAFwAYwBzADMAXABmADEAXABmAHMAMgA0AFwAdQBsAFwAYwBmADIAIABIAHkAcABlAHIAbABpAG4AawA7AH0AewBcACoAXAB0AHMANABcAHQAcwByAG8AdwBkAFwAZgAxAFwAZgBzADIANABcAHEAbABcAHQAcwBjAGUAbABsAHAAYQBkAGQAZgBsADMAXAB0AHMAYwBlAGwAbABwAGEAZABkAGwAMQAwADgAXAB0AHMAYwBlAGwAbABwAGEAZABkAGYAYgAzAFwAdABzAGMAZQBsAGwAcABhAGQAZABmAHIAMwBcAHQAcwBjAGUAbABsAHAAYQBkAGQAcgAxADAAOABcAHQAcwBjAGUAbABsAHAAYQBkAGQAZgB0ADMAXAB0AHMAdgBlAHIAdABhAGwAdABcAGMAbAB0AHgAbAByAHQAYgAgAE4AbwByAG0AYQBsACAAVABhAGIAbABlADsAfQB7AFwAKgBcAHQAcwA1AFwAdABzAHIAbwB3AGQAXABzAGIAYQBzAGUAZABvAG4ANABcAGYAMQBcAGYAcwAyADQAXABxAGwAXAB0AHIAYgByAGQAcgB0AFwAYgByAGQAcgBzAFwAYgByAGQAcgB3ADEAMABcAHQAcgBiAHIAZAByAGwAXABiAHIAZAByAHMAXABiAHIAZAByAHcAMQAwAFwAdAByAGIAcgBkAHIAYgBcAGIAcgBkAHIAcwBcAGIAcgBkAHIAdwAxADAAXAB0AHIAYgByAGQAcgByAFwAYgByAGQAcgBzAFwAYgByAGQAcgB3ADEAMABcAHQAcgBiAHIAZAByAGgAXABiAHIAZAByAHMAXABiAHIAZAByAHcAMQAwAFwAdAByAGIAcgBkAHIAdgBcAGIAcgBkAHIAcwBcAGIAcgBkAHIAdwAxADAAXAB0AHMAYwBlAGwAbABwAGEAZABkAGYAbAAzAFwAdABzAGMAZQBsAGwAcABhAGQAZABsADEAMAA4AFwAdABzAGMAZQBsAGwAcABhAGQAZABmAHIAMwBcAHQAcwBjAGUAbABsAHAAYQBkAGQAcgAxADAAOABcAHQAcwB2AGUAcgB0AGEAbAB0AFwAYwBsAHQAeABsAHIAdABiACAAVABhAGIAbABlACAAUwBpAG0AcABsAGUAIAAxADsAfQB9AHsAXAAqAFwAbABpAHMAdABvAHYAZQByAHIAaQBkAGUAdABhAGIAbABlAH0AXABuAG8AdQBpAGMAbwBtAHAAYQB0AFwAaAB0AG0AYQB1AHQAcwBwAFwAcwBwAGwAeQB0AHcAbgBpAG4AZQBcAGEAbABuAHQAYgBsAGkAbgBkAFwAZQB4AHAAcwBoAHIAdABuAFwAcwBwAGwAdABwAGcAcABhAHIAXABuAG8AZwByAG8AdwBhAHUAdABvAGYAaQB0AFwAdQB0AGkAbgBsAFwAbgBvAGIAcgBrAHcAcgBwAHQAYgBsAFwAZgB0AG4AbAB5AHQAdwBuAGkAbgBlAFwAbgBvAHQAYwB2AGEAcwBwAFwAZABuAHQAYgBsAG4AcwBiAGQAYgBcAG4AZQB3AHQAYgBsAHMAdAB5AHIAdQBsAHMAXABmAG8AcgBtAHMAaABhAGQAZQBcAHAAYQByAGQAXABwAGwAYQBpAG4AXABxAGwAXAB3AGkAZABjAHQAbABwAGEAcgBcAHMAbAAyADcANwBcAHMAbABtAHUAbAB0ADEAewBcAGYAcwAxADYAXABiAFwAYwBmADAAIABCAFwAdQAyADUAMgBcACcAZgBjAHIAbwAgAFcAYQBsAGQAcwBvAG0AcwAgAH0AewBcAGYAcwAxADYAXABjAGYAMAAgAHwAIABVAG4AdABlAHIAZwBhAHMAcwBlACAAMgAgAHwAIAAzADUANgA0ADcAIABXAGEAbABkAHMAbwBtAHMAIAB9AFwAZgBzADEANgBcAGIAXABwAGEAcgBcAHAAYQByAGQAXABwAGwAYQBpAG4AXABxAGwAXAB3AGkAZABjAHQAbABwAGEAcgBcAHMAbAAyADcANwBcAHMAbABtAHUAbAB0ADEAewBcAGYAcwAxADYAXABjAGYAMAAgAFQAZQBsAGUAZgBvAG4AIAAwACAANgAwACAAOAA1ACAALQAgADkAOAAgADkAMQAgADAAIAB8ACAARgBhAHgAIAAwACAANgAwACAAOAA1ACAALQAgADkAOAAgADkAMQAgADIAMgB9AFwAZgBzADEANgBcAHAAYQByAFwAcABhAHIAZABcAHAAbABhAGkAbgBcAHEAbABcAHcAaQBkAGMAdABsAHAAYQByAFwAcwBsADIANwA3AFwAcwBsAG0AdQBsAHQAMQB7AFwAZgBzADEANgBcAGIAXABjAGYAMAAgAEIAYQBuAGsAdgBlAHIAYgBpAG4AZAB1AG4AZwAgACAAfQB7AFwAZgBzADEANgBcAGMAZgAwACAAVgBvAGwAawBzAGIAYQBuAGsAIABCAHIAYQBuAGQAbwBiAGUAcgBuAGQAbwByAGYAIAB8ACAAQgBMAFoAIAA1ADEANQAgADkAMQAzACAAMAAwACAAfAAgAEsAdABvAC0ATgByAC4AIAA1ADAAIAA4ADAAMQAgADcAMQAzAH0AXABmAHMAMQA2AFwAcABhAHIAXABwAGEAcgBkAFwAcABsAGEAaQBuAFwAcQBsAFwAdwBpAGQAYwB0AGwAcABhAHIAXABzAGwAMgA3ADcAXABzAGwAbQB1AGwAdAAxAHsAXABmAHMAMQA2AFwAYwBmADAAIABJAEIAQQBOACAARABFADgANwAgADUAMQA1ADkAIAAxADMAMAAwACAAMAAwADUAMAAgADgAMAAxADcAIAAxADMAIAB8ACAAQgBJAEMAIABHAEUATgBvAEQARQA1ADEAVwBCAG8AfQBcAGYAcwAxADYAXABwAGEAcgBcAHAAYQByAGQAXABwAGwAYQBpAG4AXABxAGwAXAB3AGkAZABjAHQAbABwAGEAcgBcAGYAMgBcAGYAcwAyADAAXABsAGEAbgBnADEAMAAzADMAXABsAGEAbgBnAGYAZQAxADAAMwAzAFwAYwBmADEAXABwAGEAcgB9AA== + + + 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 + + \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Service/CustomHomeContentGenerator.cs b/ReportImp/PflegedienstRahnFreitag/Service/CustomHomeContentGenerator.cs new file mode 100644 index 000000000..d05aaae5b --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Service/CustomHomeContentGenerator.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts.Compact; + +namespace TemplateNeuKunde.Service +{ + //public class CustomHomeContentGenerator : HomeContentGenerator + //{ + + //Einkommentieren um Geburtstage auszublenden + // public override List GetPersonsHavingBirthday(DateTime birthdayUntil) + // { +// return new List(); + // List alle = base.GetPersonsHavingBirthday(birthdayUntil); + // List nurMitarbeiter = new List(); + + // foreach (var compactPersonDc in alle) + // { + // if (compactPersonDc.PersonType == PersonType.Employee) + // { + // nurMitarbeiter.Add(compactPersonDc); + // } + // } + // return nurMitarbeiter; + // } + //} +} diff --git a/ReportImp/PflegedienstRahnFreitag/Service/CustomVacationService.cs b/ReportImp/PflegedienstRahnFreitag/Service/CustomVacationService.cs new file mode 100644 index 000000000..46ee829e7 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Service/CustomVacationService.cs @@ -0,0 +1,45 @@ +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.DataContracts; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Text; +using System.Threading.Tasks; + + +namespace TemplateNeuKunde.Service +{ + //public class CustomVacationService : VacationService + //{ + // //public override string Bundesland { get => "Bayern"; } + + // // public override List GetFeiertage(int year, String bundesland) + // // { + // // List list = base.GetFeiertage(year, bundesland); + // // list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 31), Name = "Silvester" }); + + // // return list; + // // } + + + // //Wenn halbe Feiertage konfiguriert werden sollen, muss diese Methode auch in CustomMitarbeiterstundenkontoBerechnung einkommentiert werden + // //public override decimal GetFeiertagsFaktor(DateTime start) + // //{ + // // if (start.Month == 12) + // // { + // // if (start.Day == 24 || start.Day == 31) + // // { + // // return 0.5m; + // // } + // // } + + // // return base.GetFeiertagsFaktor(start); + // //} + //} + + +} diff --git a/ReportImp/PflegedienstRahnFreitag/Service/DefaultSaveInterceptor.cs b/ReportImp/PflegedienstRahnFreitag/Service/DefaultSaveInterceptor.cs new file mode 100644 index 000000000..28d127934 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Service/DefaultSaveInterceptor.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using BeWo.Data.Access; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.Extensions; +using BS.Shared.Services; + +namespace TemplateNeuKunde.Validation +{ + + //public class DefaultSaveInterceptor : SaveInterceptor + // { + // public override string AllowSaveCustomer(CustomerDC c) + // { + // if (c.CustomerOid.HasValue) + // { + // return null; + // } + + // if (!c.DateOfBirth.HasValue) + // { + // return "Bitte geben Sie ein Geburtsdatum an."; + // } + + // if (!String.IsNullOrWhiteSpace(c.FirstName) && !String.IsNullOrWhiteSpace(c.LastName) && c.DateOfBirth.HasValue) + // { + // var duplicates = DAOFactory.SearchDAO.FindCustomer(c.FirstName, c.LastName, c.DateOfBirth.Value); + // if (duplicates != null && duplicates.Count > 0) + // { + // var dc = duplicates[0]; + // String archiviert = ""; + + + // if (dc.Person.Sex.HasValue && dc.Person.Sex.Value == Sex.Female) + // { + // if (dc.IsActive == ActivationTypeId.Archived) + // { + // archiviert = "archivierte "; + // } + // return String.Format( + // "Es gibt bereits eine {3}Klientin {0} {1}, geb. am {2:dd.MM.yyyy}.", dc.Person.FirstName, dc.Person.LastName, dc.Person.DateOfBirth, archiviert); + // } + // else + // { + // if (dc.IsActive == ActivationTypeId.Archived) + // { + // archiviert = "archivierten "; + // } + // return String.Format( + // "Es gibt bereits einen {3}Klienten {0} {1}, geb. am {2:dd.MM.yyyy}.", dc.Person.FirstName, dc.Person.LastName, dc.Person.DateOfBirth, archiviert); + // } + // } + // } + // return base.AllowSaveCustomer(c); + // } + // } +} \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/Statistics/CustomServiceRecordStatisticFactory.cs b/ReportImp/PflegedienstRahnFreitag/Statistics/CustomServiceRecordStatisticFactory.cs new file mode 100644 index 000000000..2267e43b3 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Statistics/CustomServiceRecordStatisticFactory.cs @@ -0,0 +1,113 @@ +using System; +using System.Collections.Generic; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.DataContracts; + + +namespace TemplateNeuKunde.Statistics +{ + //public class CustomServiceRecordStatisticFactory : ServiceRecordStatisticFactory + // { + + // public override ServiceRecordStatisticsInfoDC GetServiceRecordStatisticInfo(long costBearer2SupportConceptOid, DateTime statisticsDate) + // { + // var stats = CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate); + + // var dc = new ServiceRecordStatisticsInfoDC(); + + + + // dc.Header = new string[4]; + // dc.Header[0] = "Bewilligungszeitraum:"; + // dc.Header[1] = "Geleistet diesen Monat/Gesamt:"; + // dc.Header[2] = "Bewilligt diesen Monat/Gesamt:"; + // dc.Header[3] = "Frei diesen Monat/Gesamt:"; + + // dc.ForegroundColor = new string[4]; + // dc.ForegroundColor[0] = "#FF2B508B"; + // dc.ForegroundColor[1] = "#FF2B508B"; + // dc.ForegroundColor[2] = "#FF2B508B"; + // dc.ForegroundColor[3] = "#FF2B508B"; + + // dc.PeriodStatisticInfos = new List(); + + + // if (stats != null) + // { + // if (stats.PeriodStatistics.Count > 1 && !TimeSpanIsEqual(stats)) + // dc.PeriodStatisticInfos.Add(CreateTotalStatistics(stats, statisticsDate)); + + // foreach (var pdc in stats.PeriodStatistics) + // { + // dc.PeriodStatisticInfos.Add(CreateServiceRecordPeriodStatisticsInfo(stats, pdc, statisticsDate)); + // } + // } + + // return dc; + // } + + + // public ServiceRecordPeriodStatisticsInfoDC CreateTotalStatistics(SupportConceptStatisticsDC stats, DateTime statisticsDate) + // { + // var dc = CreateDefaultServiceRecordPeriodStatisticsInfo(4); + // dc.LeftValues[0] = "Gesamt"; + + // dc.LeftValues[1] = String.Format("{0:0.00}", stats.MinutesProvidedThisMonth / 60); + // dc.RightValues[1] = String.Format("{0:0.00}", stats.MinutesProvidedTotalRounded / 60); + + // dc.LeftValues[2] = String.Format("{0:0.00}", stats.MinutesApprovedPerMonth / 60); + // dc.RightValues[2] = String.Format("{0:0.00}", stats.MinutesApprovedTotal / 60); + + // dc.LeftValues[3] = String.Format("{0:0.00}", (stats.MinutesApprovedPerMonth - stats.MinutesProvidedThisMonth) / 60); + // dc.RightValues[3] = String.Format("{0:0.00}", (stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded) / 60); + + // return dc; + // } + + // public ServiceRecordPeriodStatisticsInfoDC CreateServiceRecordPeriodStatisticsInfo(SupportConceptStatisticsDC stats, SupportConceptPeriodStatisticsDC periodStats, DateTime statisticsDate) + // { + // var dc = CreateDefaultServiceRecordPeriodStatisticsInfo(4); + + // if (periodStats.SupportConceptApprovalPeriod != null) + // { + // if (periodStats.SupportConceptApprovalPeriod.ServiceCategory != null) + // { + // dc.LeftValues[0] = String.Format("{0}: {1:dd.MM.yy} - {2:dd.MM.yy}", + // periodStats.SupportConceptApprovalPeriod.ServiceCategory.Name, + // periodStats.SupportConceptApprovalPeriod.StartDate, + // periodStats.SupportConceptApprovalPeriod.EndDate); + // } + // else + // { + // dc.LeftValues[0] = String.Format("{0:dd.MM.yy} - {1:dd.MM.yy}", + // periodStats.SupportConceptApprovalPeriod.StartDate, + // periodStats.SupportConceptApprovalPeriod.EndDate); + // } + // } + + // dc.LeftValues[1] = String.Format("{0:0.00}", periodStats.MinutesProvidedThisMonth / 60); + // dc.RightValues[1] = String.Format("{0:0.00}", periodStats.MinutesProvidedTotalRounded / 60); + + // dc.LeftValues[2] = String.Format("{0:0.00}", periodStats.MinutesApprovedPerMonth / 60); + // dc.RightValues[2] = String.Format("{0:0.00}", periodStats.MinutesApprovedTotal / 60); + + // dc.LeftValues[3] = String.Format("{0:0.00}", (periodStats.MinutesApprovedPerMonth - periodStats.MinutesProvidedThisMonth) / 60); + // dc.RightValues[3] = String.Format("{0:0.00}", (periodStats.MinutesApprovedTotal - periodStats.MinutesProvidedTotalRounded) / 60); + + // return dc; + // } + + // public override decimal GetApprovedMinutesPerMonth(SupportConceptPeriodStatisticsDC periodStats) + // { + // if (periodStats.SupportConceptApprovalPeriod != null && periodStats.SupportConceptApprovalPeriod.StartDate.HasValue && periodStats.SupportConceptApprovalPeriod.EndDate.HasValue) + // { + // if (periodStats.SupportConceptApprovalPeriod.ApprovedBEPerInterval.HasValue && periodStats.SupportConceptApprovalPeriod.ApprovedBEInterval.HasValue && periodStats.SupportConceptApprovalPeriod.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Monthly) + // { + // return periodStats.SupportConceptApprovalPeriod.ApprovedBEPerInterval.Value * 60; + // } + // } + // return base.GetApprovedMinutesPerMonth(periodStats); + // } + // } +} diff --git a/ReportImp/PflegedienstRahnFreitag/Validation/ServiceRecordValidator.cs b/ReportImp/PflegedienstRahnFreitag/Validation/ServiceRecordValidator.cs new file mode 100644 index 000000000..3e394fda6 --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/Validation/ServiceRecordValidator.cs @@ -0,0 +1,87 @@ +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.Plugins; +using BS.Shared; +using BS.Shared.DataContracts; +using BS.Shared.Extensions; + +namespace TemplateNeuKunde.Validation +{ + //public class CustomServiceRecordValidator : ServiceRecordValidator + //{ + // public override string[] GetIgnoreCategoriesForOverlappingCheck() + // { + // return new[] { "Arbeitszeiterfassung" }; + // } + + + // public override List ValidateServiceRecord(ServiceRecordDC newServiceRecord, SupportConceptStatisticsDC statistics, + // int maxDaysEditServiceRecordsAllowed, IList employeeOids, IList cb2scOids) + // { + // var list = base.ValidateServiceRecord(newServiceRecord, statistics, maxDaysEditServiceRecordsAllowed, employeeOids, cb2scOids); + + // if (newServiceRecord.ServiceDescription.Category.IsBillable && newServiceRecord.RoundedDuration == 0) + // { + + // list.Add(new ServiceRecordValidationResultDC + // { + // ResultType = ServiceRecordValidationResult.Custom, + // Message = "Die Dauer muss größer als 0 sein." + // }); + + // } + + // var sd = newServiceRecord.ServiceDescription.Name.ToLower(); + // var cat = newServiceRecord.ServiceDescription.Category.Name.ToLower(); + + // if (cat.Contains("arztbesuch") || + // cat.Contains("krank") || + // cat.Contains("fortbildung") || + // cat.Contains("urlaub") || + // cat.Contains("indirekte zeiten") || + // (cat.Contains("betrieb") && cat.Contains("zeiten"))) + // { + // if (sd.Contains("abwesend")) + // { + + // list.Add(new ServiceRecordValidationResultDC + // { + // ResultType = ServiceRecordValidationResult.Custom, + // Message = "Dieser Eintrag kann nur von Fachleitungen oder Bereichsleitungen angelegt werden." + // }); + // } + // } + + + + // bool hasZukunftResult = false; + + // foreach (var r in list) + // { + // if (r.ResultType == ServiceRecordValidationResult.Custom && r.Message.Contains("Zukunft")) + // { + // hasZukunftResult = true; + // } + // } + // if (!hasZukunftResult) + // { + // if (newServiceRecord.End.Value > DateTime.Now.AddMinutes(20)) + // { + // list.Add(new ServiceRecordValidationResultDC + // { + // ResultType = ServiceRecordValidationResult.Custom, + // Message = "Das gewählte Datum darf nicht in der Zukunft liegen." + // }); + // } + // } + + + // return list; + // } + // } +} \ No newline at end of file diff --git a/ReportImp/PflegedienstRahnFreitag/app.config b/ReportImp/PflegedienstRahnFreitag/app.config new file mode 100644 index 000000000..677131bde --- /dev/null +++ b/ReportImp/PflegedienstRahnFreitag/app.config @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file