lyndon.jetten@ownsoft.de
623cac6b1e
1. die ServiceRecords des letzten Tages eines Monats bei der Zeitraumwahl "Monat" wurden nicht angezeigt, weil EndDate.Date benutzt wurde. 2. Warnung, dass eine Monatsunterschrift besteht, wenn man einen ServiceRecord anlegt, wird nur noch angezeigt, wenn es sich um eine abrechenbare Kategorie handelt. FaC: Problem mit BeforePrint-Events beim QB von der Diakonie Kirchenkreis Kleve behoben, aber Kojo hatte das schon vor mir gefixt.
6524 lines
315 KiB
C#
6524 lines
315 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Data.Utils;
|
|
using BeWo.View.Navigation.Filter;
|
|
using BS.Shared.Extensions;
|
|
using NHibernate;
|
|
using NHibernate.Criterion;
|
|
using NHibernate.Engine;
|
|
using NHibernate.Impl;
|
|
using NHibernate.Loader.Criteria;
|
|
using NHibernate.Persister.Entity;
|
|
using NHibernate.SqlCommand;
|
|
|
|
using BS.Shared.Core;
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
using DevExpress.XtraScheduler;
|
|
using DevExpress.XtraScheduler.Compatibility;
|
|
using NHibernate.Transform;
|
|
using static System.String;
|
|
using Appointment = BeWo.Data.Entities.Appointment;
|
|
using Login = BeWo.Data.Entities.Login;
|
|
using Resource = BeWo.Data.Entities.Resource;
|
|
|
|
namespace BeWo.Data.Access
|
|
{
|
|
public class SearchDAO : AbstractBaseDAO
|
|
{
|
|
private static readonly Regex RecurrenceIdRegex = new Regex("(Id=\\\"[a-z0-9-]+\\\")");
|
|
|
|
public IEnumerable<ValueListEntry> FindValueListEntry(ValueListEntryType pType)
|
|
{
|
|
return CreateCriteria<ValueListEntry>().Add(Restrictions.Eq(ValueListEntry.PropertyName_Type, pType)).AddOrder(Order.Asc(ValueListEntry.PropertyName_Value)).List<ValueListEntry>();
|
|
}
|
|
|
|
public IEnumerable<ValueListEntry> FindValueListEntries(List<ValueListEntryType> pTypes)
|
|
{
|
|
return CreateCriteria<ValueListEntry>().Add(Restrictions.In(ValueListEntry.PropertyName_Type, pTypes)).AddOrder(Order.Asc(ValueListEntry.PropertyName_Value)).List<ValueListEntry>();
|
|
}
|
|
|
|
public virtual IEnumerable<Employee> FindEmployee(string pFirstName, string pLastName, string pPersonnelNumber)
|
|
{
|
|
return CreateCriteria<Employee>()
|
|
.Add(Restrictions.Like(Employee.PropertyName_PersonnelNumber, pPersonnelNumber, MatchMode.Anywhere))
|
|
.CreateCriteria(Employee.PropertyName_Person, JoinType.InnerJoin)
|
|
.Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere))
|
|
.List<Employee>();
|
|
}
|
|
|
|
public virtual Employee FindEmployeeByFullname(string pFullname)
|
|
{
|
|
var q = Session.CreateSQLQuery(Format("SELECT e.oid FROM employee e join Person p on e.personoid = p.oid WHERE CONCAT_WS(' ', FirstName, LastName) LIKE '%{0}%' AND Type = 1", pFullname));
|
|
var x = q.List<long>();
|
|
|
|
return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Employee>(x.Last()) : null;
|
|
}
|
|
|
|
public virtual IEnumerable<Wohnheim> FindWohnheim(string pwohnheimName, string pWohnheimStrasse, string pWohnheimPlz)
|
|
{
|
|
return CreateCriteria<Wohnheim>()
|
|
.Add(Restrictions.Like(Wohnheim.PropertyName_WohnheimName, pwohnheimName, MatchMode.Anywhere))
|
|
.CreateCriteria(Wohnheim.PropertyName_Wohnheim, JoinType.InnerJoin)
|
|
.Add(Restrictions.Like(Wohnheim.PropertyName_Strasse, pWohnheimStrasse, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Wohnheim.PropertyName_PlZ, pWohnheimPlz, MatchMode.Anywhere))
|
|
.List<Wohnheim>();
|
|
}
|
|
|
|
public virtual Wohnheim FindWohnheimByFullname(string pWohnheimName)
|
|
{
|
|
var q = Session.CreateSQLQuery(Format("SELECT Oid FROM Wohnheim WHERE CONCAT_WS(' ', WohnheimName) LIKE '%{0}%'", pWohnheimName));
|
|
var x = q.List<long>();
|
|
|
|
return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Wohnheim>(x.First()) : null;
|
|
}
|
|
|
|
public virtual IEnumerable<Customer> FindCustomer(string pFirstName, string pLastName, string pReferenceNumber)
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.Add(Restrictions.Like(Customer.PropertyName_ReferenceNumber, pReferenceNumber, MatchMode.Anywhere))
|
|
.CreateCriteria(Customer.PropertyName_Person, JoinType.InnerJoin)
|
|
.Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public virtual IList<Customer> FindCustomer(string pFirstName, string pLastName, DateTime pBirthDate)
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Customer>()
|
|
.CreateCriteria(Customer.PropertyName_Person, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(Person.PropertyName_FirstName, pFirstName))
|
|
.Add(Restrictions.Eq(Person.PropertyName_LastName, pLastName))
|
|
.Add(Restrictions.Eq(Person.PropertyName_DateOfBirth, pBirthDate))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public virtual IList<DienstEintrag> GetAllDienstEintraege(long wOid, DateTime start, DateTime end)
|
|
{
|
|
var c = CreateCriteria<DienstEintrag>()
|
|
.Add(Restrictions.Eq("WohnheimOid", wOid))
|
|
.Add(Restrictions.Between("Datum", start, end))
|
|
.Add(Restrictions.Eq("IsActive", ActivationTypeId.Active));
|
|
|
|
return c.List<DienstEintrag>();
|
|
}
|
|
|
|
public virtual IList<Employee> GetEmployeeForWohnheim(long wOid)
|
|
{
|
|
var c = CreateCriteria<Wohnheim>()
|
|
.Add(Restrictions.Eq("WohnheimOid", wOid));
|
|
|
|
return c.List<Employee>();
|
|
}
|
|
|
|
public virtual IEnumerable<Person> FindPerson(string pFirstName, string pLastName, DateTime? pDateOfBirth, PersonType? pPersonType)
|
|
{
|
|
var lCriteria = CreateCriteria<Person>()
|
|
.Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere));
|
|
if(pDateOfBirth != null)
|
|
lCriteria.Add(Restrictions.Eq(Person.PropertyName_DateOfBirth, pDateOfBirth));
|
|
if(pPersonType != null)
|
|
lCriteria.Add(Restrictions.Eq(Person.PropertyName_Type, pPersonType));
|
|
|
|
return lCriteria.List<Person>();
|
|
}
|
|
|
|
public virtual IEnumerable<Organisation> FindOrganisation(string pName, bool pOnlyCostBearer)
|
|
{
|
|
var lCriteria = CreateCriteria<Organisation>()
|
|
.Add(Restrictions.Like(Organisation.PropertyName_Name, pName, MatchMode.Anywhere));
|
|
|
|
if(pOnlyCostBearer)
|
|
lCriteria.Add(Restrictions.IsNotNull(Organisation.PropertyName_CostBearer));
|
|
|
|
return lCriteria.List<Organisation>();
|
|
}
|
|
|
|
public virtual IEnumerable<Team> FindTeams(string pTeamName, string pLeaderFirstName, string pLeaderLastName)
|
|
{
|
|
return CreateCriteria<Team>()
|
|
.Add(Restrictions.Like(Team.PropertyName_Name, pTeamName, MatchMode.Anywhere))
|
|
.CreateCriteria(Team.PropertyName_Leader, JoinType.InnerJoin)
|
|
.CreateCriteria(Employee.PropertyName_Person)
|
|
.Add(Restrictions.Like(Person.PropertyName_FirstName, pLeaderFirstName, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Person.PropertyName_LastName, pLeaderLastName, MatchMode.Anywhere))
|
|
.List<Team>();
|
|
}
|
|
|
|
public virtual IList<Team> FindTeamsOfEmployee(long employeeOid)
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Team>()
|
|
.CreateCriteria(Team.PropertyName_MemberList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid))
|
|
.List<Team>();
|
|
}
|
|
|
|
public virtual IEnumerable<Team> FindLeadingTeams(long employeeOid)
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Team>()
|
|
.CreateCriteria(Team.PropertyName_Leader, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid))
|
|
.List<Team>();
|
|
}
|
|
|
|
public virtual IList<Team> FindAllActiveTeamsOfEmployee(long employeeOid)
|
|
{
|
|
return CreateCriteriaIsActive<Team>()
|
|
.CreateAlias(Team.PropertyName_MemberList, "m", JoinType.InnerJoin)
|
|
.CreateAlias(Team.PropertyName_Leader, "l", JoinType.InnerJoin)
|
|
.Add(Restrictions.Disjunction()
|
|
.Add(Restrictions.Eq("m." + BeWoEntityBase.PropertyName_Oid, employeeOid))
|
|
.Add(Restrictions.Eq("l." + BeWoEntityBase.PropertyName_Oid, employeeOid)))
|
|
.List<Team>().Distinct().ToList();
|
|
|
|
}
|
|
|
|
public virtual IList<Customer> FindCustomerOfTeam(long teamOid)
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Customer>()
|
|
.CreateCriteria(Customer.PropertyName_Team2CustomerList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(Team2Customer.PropertyName_TeamOid, teamOid))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<ResourceBookingSequence> FindBookings(long pResourceOid, DateTime pSpanStart, DateTime pSpanEnd)
|
|
{
|
|
var lResult = CreateCriteria<ResourceBookingSequence>()
|
|
.CreateAlias(ResourceBookingSequence.PropertyName_Resource, "r")
|
|
.CreateAlias(ResourceBookingSequence.PropertyName_Details, "d")
|
|
.Add(Restrictions.Eq("r." + BeWoEntityBase.PropertyName_Oid, pResourceOid))
|
|
.Add(Restrictions.Eq("d." + ResourceBooking.PropertyName_SequencePosition, 0))
|
|
.Add(Restrictions.Disjunction()
|
|
.Add(Restrictions.Between("d." + ResourceBooking.PropertyName_Start, pSpanStart, pSpanEnd))
|
|
.Add(Restrictions.Between(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanStart, pSpanEnd))
|
|
.Add(Restrictions.Conjunction()
|
|
.Add(Restrictions.Le("d." + ResourceBooking.PropertyName_Start, pSpanStart))
|
|
.Add(Restrictions.Ge(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanEnd))
|
|
)
|
|
)
|
|
.List<ResourceBookingSequence>();
|
|
|
|
return lResult;
|
|
}
|
|
|
|
public IEnumerable<ResourceBookingSequence> FindBookings(DateTime pSpanStart, DateTime pSpanEnd)
|
|
{
|
|
var lResult = CreateCriteria<ResourceBookingSequence>()
|
|
.CreateAlias(ResourceBookingSequence.PropertyName_Details, "d")
|
|
.Add(Restrictions.Eq("d." + ResourceBooking.PropertyName_SequencePosition, 0))
|
|
.Add(Restrictions.Disjunction()
|
|
.Add(Restrictions.Between("d." + ResourceBooking.PropertyName_Start, pSpanStart, pSpanEnd))
|
|
.Add(Restrictions.Between(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanStart, pSpanEnd))
|
|
.Add(Restrictions.Conjunction()
|
|
.Add(Restrictions.Le("d." + ResourceBooking.PropertyName_Start, pSpanStart))
|
|
.Add(Restrictions.Ge(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanEnd))
|
|
)
|
|
)
|
|
.List<ResourceBookingSequence>();
|
|
|
|
return lResult;
|
|
}
|
|
|
|
public void RemoveServiceRecordsFromAppointments(IEnumerable<long> enumerable)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public List<ServiceRecord> FindServiceRecords(long? pEmployeeOid, long? pCostBearer2SupportConceptOid)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin);
|
|
|
|
if(pCostBearer2SupportConceptOid.HasValue)
|
|
{
|
|
c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
|
|
.CreateAlias("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, "c2s", JoinType.InnerJoin);
|
|
}
|
|
|
|
if(pEmployeeOid.HasValue)
|
|
c = c.Add(Restrictions.Eq("e." + BeWoEntityBase.PropertyName_Oid, pEmployeeOid));
|
|
if(pCostBearer2SupportConceptOid.HasValue)
|
|
c = c.Add(Restrictions.Eq("c2s." + BeWoEntityBase.PropertyName_Oid, pCostBearer2SupportConceptOid));
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public List<ServiceRecord> FindServiceRecordsForSupportConcept(long pSupportConceptOid)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin);
|
|
|
|
c = c.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_Oid, pSupportConceptOid));
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public List<ServiceRecord> FindServiceRecords(long? supportConceptOid, long? costBearer2SupportConceptOid, long? serviceCategoryOid, DateTime? start, DateTime? end)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin);
|
|
|
|
if(supportConceptOid.HasValue)
|
|
{
|
|
c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin);
|
|
}
|
|
|
|
if(serviceCategoryOid.HasValue)
|
|
{
|
|
c = c.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "cat", JoinType.InnerJoin);
|
|
}
|
|
|
|
if(supportConceptOid.HasValue)
|
|
{
|
|
c = c.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_Oid, supportConceptOid));
|
|
}
|
|
|
|
if(costBearer2SupportConceptOid.HasValue)
|
|
{
|
|
c = c.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
|
|
}
|
|
|
|
if(serviceCategoryOid.HasValue)
|
|
{
|
|
c = c.Add(Restrictions.Eq("cat." + BeWoEntityBase.PropertyName_Oid, serviceCategoryOid));
|
|
}
|
|
|
|
if(start.HasValue && end.HasValue)
|
|
{
|
|
c.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, start, end));
|
|
}
|
|
//{
|
|
// c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
|
|
// .CreateAlias("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, "c2s", JoinType.InnerJoin);
|
|
//}
|
|
|
|
//if (pEmployeeOid.HasValue)
|
|
// c = c.Add(Restrictions.Eq("e." + BeWoEntityBase.PropertyName_Oid, pEmployeeOid));
|
|
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IList<SupportConceptApprovalPeriod2Employee> FindSupportConceptApprovalPeriod2Employees(Employee emp)
|
|
{
|
|
var c = CreateCriteria<SupportConceptApprovalPeriod2Employee>()
|
|
.Add(Restrictions.Eq(SupportConceptApprovalPeriod2Employee.PropertyName_Employee, emp));
|
|
return c.List<SupportConceptApprovalPeriod2Employee>().ToList();
|
|
}
|
|
|
|
public IList<SupportConceptApprovalPeriod2Employee> FindSupportConceptApprovalPeriod2Employees(SupportConceptApprovalPeriod scap)
|
|
{
|
|
var c = CreateCriteria<SupportConceptApprovalPeriod2Employee>()
|
|
.Add(Restrictions.Eq(SupportConceptApprovalPeriod2Employee.PropertyName_SupportConceptApprovalPeriod, scap));
|
|
return c.List<SupportConceptApprovalPeriod2Employee>().ToList();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindServiceRecordsInSpan(long pCostBearer2SupportConceptOid, DateTimeSpan period)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, pCostBearer2SupportConceptOid));
|
|
|
|
if(period != null)
|
|
criteria =
|
|
criteria.Add(
|
|
Restrictions.Or(
|
|
Restrictions.Between(ServiceRecord.PropertyName_Start, period.StartDateTime, period.EndDateTime),
|
|
Restrictions.Between(ServiceRecord.PropertyName_End, period.StartDateTime, period.EndDateTime)));
|
|
|
|
return criteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecordHistory> FindServiceRecordHistory(long serviceRecordOid)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecordHistory>()
|
|
.Add(Restrictions.Eq(ServiceRecordHistory.PropertyName_ServiceRecordOid, serviceRecordOid));
|
|
|
|
|
|
return criteria.List<ServiceRecordHistory>().ToList();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomer(long pEmployeeOid, long? days)
|
|
{
|
|
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
if(days.HasValue)
|
|
{
|
|
var minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
|
|
}
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerInSpan(long pEmployeeOid, DateTimeSpan period)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
if(period != null)
|
|
{
|
|
criteria =
|
|
criteria.Add(
|
|
Restrictions.Or(
|
|
Restrictions.Between(ServiceRecord.PropertyName_Start, period.StartDateTime, period.EndDateTime),
|
|
Restrictions.Between(ServiceRecord.PropertyName_End, period.StartDateTime, period.EndDateTime)));
|
|
}
|
|
|
|
return criteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerWithStartEndDate(long pEmployeeOid, DateTime start, DateTime ende)
|
|
{
|
|
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
var max = ende.Date.AddDays(1);
|
|
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, max.Date));
|
|
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindEmployeeServiceRecords(long pEmployeeOid, DateTimeSpan pSpan, long? customerOid, ServiceRecordTypeId? srTypeFilter)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid));
|
|
|
|
if(pSpan != null)
|
|
lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
if(customerOid != null)
|
|
lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid.Value));
|
|
if(srTypeFilter.HasValue)
|
|
{
|
|
lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
|
|
}
|
|
|
|
var result = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<ServiceRecord> FindCustomerServiceRecords(long customerOid)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid));
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindCustomerServiceRecords(long customerOid, DateTimeSpan pSpan, long? employeeOid, ServiceRecordTypeId? srTypeFilter, bool includeEndDateInSearch)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid));
|
|
|
|
|
|
if(includeEndDateInSearch)
|
|
{
|
|
var orCriteria = Restrictions.Or(
|
|
Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime),
|
|
Restrictions.Between(ServiceRecord.PropertyName_End, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
|
|
orCriteria = Restrictions.Or(orCriteria,
|
|
Restrictions.And(
|
|
Restrictions.Le(ServiceRecord.PropertyName_Start, pSpan.EndDateTime),
|
|
Restrictions.Ge(ServiceRecord.PropertyName_End, pSpan.StartDateTime)));
|
|
|
|
|
|
lCriteria.Add(orCriteria);
|
|
}
|
|
else
|
|
{
|
|
lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
}
|
|
|
|
|
|
|
|
if(employeeOid != null)
|
|
lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid.Value));
|
|
if(srTypeFilter.HasValue)
|
|
{
|
|
lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
|
|
}
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindServiceRecordsInSpan(DateTimeSpan pSpan, ServiceRecordTypeId? srTypeFilter)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
if(srTypeFilter.HasValue)
|
|
{
|
|
lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
|
|
}
|
|
|
|
return lCriteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IEnumerable<AccountingTransaction> FindUnassignedAccountingTransactions()
|
|
{
|
|
return CreateCriteria<AccountingTransaction>()
|
|
.Add(Restrictions.IsNull(AccountingTransaction.PropertyName_CostBearer2SupportConcept))
|
|
.List<AccountingTransaction>().ToList();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> FindSupportConcept(
|
|
string pCustomerFirstName,
|
|
string pCustomerLastName,
|
|
string pCustomerReferenceNumber,
|
|
DateTime? pFrom,
|
|
DateTime? pTill)
|
|
{
|
|
var lCriteria = CreateCriteria<SupportConcept>();
|
|
|
|
//if (pFrom != null)
|
|
// lCriteria.Add(Expression.Ge(SupportConcept.PropertyName_Start, pFrom));
|
|
//if (pTill != null)
|
|
// lCriteria.Add(Expression.Le(SupportConcept.PropertyName_End, pTill));
|
|
|
|
lCriteria = lCriteria.CreateCriteria(SupportConcept.PropertyName_Customer, JoinType.InnerJoin);
|
|
|
|
if(!IsNullOrEmpty(pCustomerReferenceNumber))
|
|
lCriteria.Add(Restrictions.Eq(Customer.PropertyName_ReferenceNumber, pCustomerReferenceNumber));
|
|
|
|
if(!BS.Shared.Core.Utils.AreAllNullOrEmpty(pCustomerFirstName, pCustomerLastName))
|
|
lCriteria.CreateCriteria(Customer.PropertyName_Person)
|
|
.Add(Restrictions.Like(Person.PropertyName_FirstName, pCustomerFirstName, MatchMode.Anywhere))
|
|
.Add(Restrictions.Like(Person.PropertyName_LastName, pCustomerLastName, MatchMode.Anywhere));
|
|
|
|
return lCriteria.List<SupportConcept>();
|
|
}
|
|
|
|
public TwoFactorCode GetLastTwoFactorCode(string loginName, string bCryptPassword)
|
|
{
|
|
return CreateCriteriaIsActive<TwoFactorCode>()
|
|
.Add(Expression.Eq("LoginName", loginName))
|
|
.Add(Expression.Eq("Password", bCryptPassword))
|
|
.AddOrder(new Order("Oid", false)).List<TwoFactorCode>().FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> FindCurrentSupportConcepts()
|
|
{
|
|
return CreateCriteriaIsActive<SupportConcept>()
|
|
//.Add(Expression.Ge(SupportConcept.PropertyName_End, DateTime.Now))
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> FindSupportConceptsInSpan(DateTimeSpan pSpan)
|
|
{
|
|
return CreateCriteriaIsActive<SupportConcept>()
|
|
//.Add(Expression.Disjunction()
|
|
// .Add(Expression.Between(SupportConcept.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime))
|
|
// .Add(Expression.Between(SupportConcept.PropertyName_End, pSpan.StartDateTime, pSpan.EndDateTime))
|
|
// .Add(Expression.Conjunction()
|
|
// .Add(Expression.Le(SupportConcept.PropertyName_Start, pSpan.StartDateTime))
|
|
// .Add(Expression.Ge(SupportConcept.PropertyName_End, pSpan.EndDateTime))
|
|
// )
|
|
// )
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> FindExpiringSupportConcepts(long? employeeOid, DateTime minDate, DateTime expiredUntil)
|
|
{
|
|
var c = CreateCriteriaIsActive<SupportConcept>();
|
|
if(employeeOid == null)
|
|
{
|
|
return c
|
|
.CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Between(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, minDate, expiredUntil))
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
return c
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateAlias("c.Employee2CustomerList", "e2c", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("e2c." + Employee2Customer.PropertyName_EmployeeOid, employeeOid.Value))
|
|
.Add(Restrictions.Or(Restrictions.Or(
|
|
Restrictions.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, minDate, expiredUntil),
|
|
Restrictions.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, minDate, expiredUntil)),
|
|
Restrictions.And(Restrictions.IsNotNull("c.TerminationDate"), Restrictions.Between("c.TerminationDate", minDate, expiredUntil))))
|
|
.List<SupportConcept>().Distinct().ToList();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> FindSupportConceptsWithConferenceDate(long? employeeOid, DateTime conferenceDateUntil)
|
|
{
|
|
var c = CreateCriteriaIsActive<SupportConcept>();
|
|
if(employeeOid == null)
|
|
{
|
|
return c
|
|
.Add(Restrictions.Between(SupportConcept.PropertyName_ConferenceDate, DateTime.Now, conferenceDateUntil))
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
return c
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateAlias("c.Employee2CustomerList", "e2c", JoinType.InnerJoin)
|
|
.Add(Restrictions.Between(SupportConcept.PropertyName_ConferenceDate, DateTime.Now.Date, conferenceDateUntil))
|
|
.Add(Restrictions.Eq("e2c." + Employee2Customer.PropertyName_EmployeeOid, employeeOid.Value))
|
|
.List<SupportConcept>().Distinct().ToList();
|
|
}
|
|
|
|
public ApplicationUser FindUserForEmployee(Employee employee)
|
|
{
|
|
return CreateCriteriaIsActive<ApplicationUser>()
|
|
.Add(Restrictions.Eq(ApplicationUser.PropertyName_Employee, employee))
|
|
.List<ApplicationUser>().FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<Person> FindPersonsHavingBirthday(DateTime birthdayUntil)
|
|
{
|
|
var ts = birthdayUntil.Subtract(DateTime.Now);
|
|
var days = ts.Days + 1;
|
|
|
|
return CreateCriteriaIsActive<Person>()
|
|
.Add(Expression.Sql(new SqlString("dayofyear(CAST(CONCAT(Year(CURDATE()), '-', Month(" + Person.PropertyName_DateOfBirth + "), '-', Day(" + Person.PropertyName_DateOfBirth + ")) AS DATE )) between dayofyear(CURDATE()) -4 and dayofyear(CURDATE()) + " + days)))
|
|
.List<Person>();
|
|
}
|
|
|
|
public IEnumerable<Login> FindLastLogins(string loginName, int maxResults)
|
|
{
|
|
return CreateCriteria<Login>()
|
|
.Add(Restrictions.Eq(Login.PropertyName_LoginName, loginName))
|
|
.AddOrder(Order.Desc("Oid"))
|
|
.SetMaxResults(maxResults)
|
|
.List<Login>();
|
|
}
|
|
|
|
public IEnumerable<Query> FindQuery(QueryType pType)
|
|
{
|
|
return CreateCriteria<Query>().Add(Restrictions.Eq(Query.PropertyName_Type, pType))
|
|
.List<Query>().ToList();
|
|
}
|
|
|
|
public IList<AccountingTransaction> FindAccoutingTransactions(DateTimeSpan pSpan)
|
|
{
|
|
var lCriteria = CreateCriteriaIsActive<AccountingTransaction>();
|
|
|
|
if(pSpan != null)
|
|
lCriteria.Add(Restrictions.Between(AccountingTransaction.PropertyName_BookingDate, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
|
|
var test = lCriteria.List<AccountingTransaction>();
|
|
|
|
return test;
|
|
}
|
|
|
|
public IEnumerable<AccountingTransaction> FindAccoutingTransactions(DateTimeSpan pSpan, long? pSupportConceptOid, long? pSupportConceptCostBearerRelOid)
|
|
{
|
|
var lCriteria = CreateCriteriaIsActive<AccountingTransaction>()
|
|
.CreateAlias(AccountingTransaction.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.LeftOuterJoin);
|
|
|
|
if(pSpan != null)
|
|
lCriteria.Add(Restrictions.Between(AccountingTransaction.PropertyName_BookingDate, pSpan.StartDateTime, pSpan.EndDateTime));
|
|
|
|
if(pSupportConceptCostBearerRelOid != null)
|
|
lCriteria.Add(Restrictions.Eq("cb2sc." + BeWoEntityBase.PropertyName_Oid, pSupportConceptCostBearerRelOid));
|
|
|
|
if(pSupportConceptOid != null)
|
|
{
|
|
lCriteria.CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_SupportConcept)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pSupportConceptOid));
|
|
}
|
|
|
|
var test = lCriteria.List<AccountingTransaction>();
|
|
|
|
return test;
|
|
}
|
|
|
|
public IList<Settings> FindSettingsByValuePart(SettingsType pType, string pValuePart)
|
|
{
|
|
return CreateCriteria<Settings>()
|
|
.Add(Restrictions.Eq(Settings.PropertyName_Type, pType))
|
|
.Add(Restrictions.Like(Settings.PropertyName_Value, pValuePart, MatchMode.Anywhere))
|
|
.List<Settings>();
|
|
}
|
|
|
|
public IList<FileAttachment> FindFileAttachments(TableID pObjTid, long pObjOid)
|
|
{
|
|
return CreateCriteriaIsActive<FileAttachment>()
|
|
.Add(Restrictions.Eq(FileAttachment.PropertyName_ObjectOid, pObjOid))
|
|
.Add(Restrictions.Eq(FileAttachment.PropertyName_ObjectTid, pObjTid))
|
|
.List<FileAttachment>();
|
|
}
|
|
|
|
public IEnumerable<FileAttachmentInfo> FindFileAttachmentInfos(TableID pObjTid, long pObjOid)
|
|
{
|
|
return CreateCriteriaIsActive<FileAttachmentInfo>()
|
|
.Add(Restrictions.Eq(FileAttachmentInfo.PropertyName_ObjectOid, pObjOid))
|
|
.Add(Restrictions.Eq(FileAttachmentInfo.PropertyName_ObjectTid, pObjTid))
|
|
.List<FileAttachmentInfo>();
|
|
}
|
|
|
|
public IList<BeWoFolder> FindBeWoFolders(TableID pObjTid, long pObjOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<BeWoFolder>()
|
|
.Add(Restrictions.Eq(BeWoFolder.PropertyName_ObjectTid, pObjTid));
|
|
|
|
if(pObjOid > 0)
|
|
{
|
|
c.Add(Restrictions.Eq(BeWoFolder.PropertyName_ObjectOid, pObjOid));
|
|
}
|
|
|
|
return c.List<BeWoFolder>();
|
|
}
|
|
|
|
//public IList<SupportConcept> FindAllActiveApprovedLVRSupportConcepts()
|
|
//{
|
|
// return CreateCriteriaIsActive<SupportConcept>()
|
|
// .CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
|
|
// .Add(Expression.Eq(CostBearer2SupportConcept.PropertyName_Status, CostBearer2SupportConceptStatus.Approved))
|
|
// .CreateCriteria(CostBearer2SupportConcept.PropertyName_CostBearer, JoinType.InnerJoin)
|
|
// .Add(Expression.Eq(CostBearer.PropertyName_SystemEntryID, SystemEntryID.CostBearerLVR))
|
|
// .List<SupportConcept>();
|
|
//}
|
|
|
|
public IList<SupportConcept> FindAllActiveApprovedSupportConcepts()
|
|
{
|
|
return CreateCriteriaIsActive<SupportConcept>()
|
|
.CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(CostBearer2SupportConcept.PropertyName_Status, CostBearer2SupportConceptStatus.Approved))
|
|
|
|
.List<SupportConcept>().Distinct().ToList();
|
|
}
|
|
|
|
public Employee FindEmployeeWithPersonOid(long pPersonOid)
|
|
{
|
|
var person = DAOFactory.GenericDAO.LoadByID<Person>(pPersonOid);
|
|
if(person != null)
|
|
{
|
|
return CreateCriteria<Employee>()
|
|
.Add(Restrictions.Eq(Employee.PropertyName_Person, person)).UniqueResult<Employee>();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Customer FindCustomerWithPersonOid(long pPersonOid)
|
|
{
|
|
var person = DAOFactory.GenericDAO.LoadByID<Person>(pPersonOid);
|
|
if(person != null)
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.Add(Restrictions.Eq(Customer.PropertyName_Person, person)).UniqueResult<Customer>();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public IList<Customer> FindCustomersWithPersonOids(IEnumerable<long> pPersonOid)
|
|
{
|
|
|
|
return CreateCriteriaIsActive<Customer>()
|
|
.CreateAlias(Customer.PropertyName_Person, "p", JoinType.InnerJoin)
|
|
.Add(Restrictions.In("p." + BeWoEntityBase.PropertyName_Oid, pPersonOid.ToArray()))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IList<Person> GetActivePersonsWithType(PersonType type)
|
|
{
|
|
return CreateCriteriaIsActive<Person>()
|
|
.Add(Restrictions.Eq(Person.PropertyName_Type, type))
|
|
.List<Person>();
|
|
}
|
|
|
|
public IEnumerable<Customer> GetAllActiveCustomersWithSupportConceptData()
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Customer>()
|
|
.CreateAlias(Customer.PropertyName_SupportConcepts, "sc", JoinType.LeftOuterJoin)
|
|
.CreateCriteria("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.LeftOuterJoin)
|
|
.Add(Restrictions.Eq("sc." + SupportConcept.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<Customer> GetAllActiveCustomersWithAddress()
|
|
{
|
|
return CreateCriteriaIsActive<Customer>()
|
|
.CreateCriteria(Customer.PropertyName_Person, JoinType.LeftOuterJoin)
|
|
.CreateCriteria(Person.PropertyName_Address, JoinType.LeftOuterJoin)
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<Customer> GetAllCustomersWithRelatedEmployee()
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.CreateAlias("Person", "cp", JoinType.InnerJoin)
|
|
.CreateAlias("cp." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
|
|
.CreateAlias("Employee2CustomerList", "e2c", JoinType.LeftOuterJoin)
|
|
.CreateAlias("e2c." + Employee2Customer.PropertyName_Employee, "e", JoinType.LeftOuterJoin)
|
|
.CreateCriteria("e2c." + Employee2Customer.PropertyName_ValueList, JoinType.LeftOuterJoin)
|
|
.CreateCriteria("e." + Employee.PropertyName_Person, JoinType.LeftOuterJoin)
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindServiceRecordsDetailsForLastDays(long costbearer2SupportConcept, long? days)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
if(days.HasValue)
|
|
{
|
|
|
|
var minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
|
|
}
|
|
|
|
return c.CreateAlias(ServiceRecord.PropertyName_ValueList, "vl", JoinType.LeftOuterJoin)
|
|
.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin)
|
|
.CreateCriteria("e." + Employee.PropertyName_Person, JoinType.InnerJoin)
|
|
.List<ServiceRecord>().Distinct().ToList();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindServiceRecordsDetailsForLastDaysWithStartEndDate(long costbearer2SupportConcept, DateTime start, DateTime ende)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
|
|
var max = ende.Date.AddDays(1);
|
|
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, max.Date));
|
|
|
|
var result = c.CreateAlias(ServiceRecord.PropertyName_ValueList, "vl", JoinType.LeftOuterJoin)
|
|
.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin)
|
|
.CreateCriteria("e." + Employee.PropertyName_Person, JoinType.InnerJoin)
|
|
.List<ServiceRecord>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<ServiceRecord> FindServiceRecordsDetailWithServiceInfo(long costbearer2SupportConcept)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
|
|
return c.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.List<ServiceRecord>();
|
|
}
|
|
|
|
public Customer FindCustomerWithServiceRecordsWithDetail(long pCustomerOid)
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pCustomerOid))
|
|
.CreateAlias(Customer.PropertyName_ServiceRecordList, "sr", JoinType.InnerJoin)
|
|
.CreateCriteria("sr." + ServiceRecord.PropertyName_ValueList, JoinType.LeftOuterJoin)
|
|
.CreateAlias("sr." + ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateCriteria("sd." + ServiceDescription.PropertyName_ServiceCategory, JoinType.InnerJoin)
|
|
.CreateAlias("sr." + ServiceRecord.PropertyName_CostBearer2SupportConcept, "c2s", JoinType.InnerJoin)
|
|
.CreateCriteria("c2s." + CostBearer2SupportConcept.PropertyName_SupportConcept, JoinType.InnerJoin)
|
|
.CreateAlias("c2s." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
|
|
.CreateAlias("cb." + CostBearer.PropertyName_Organisation, "org", JoinType.InnerJoin)
|
|
.UniqueResult<Customer>();
|
|
}
|
|
|
|
public ServiceRecordGroup FindServiceRecordGroup(long pGroupOid)
|
|
{
|
|
return CreateCriteria<ServiceRecordGroup>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pGroupOid))
|
|
.CreateCriteria(ServiceRecordGroup.PropertyName_ServiceRecordList, JoinType.InnerJoin)
|
|
.UniqueResult<ServiceRecordGroup>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> GetAllActiveAndArchivedSupportConceptsCompact()
|
|
{
|
|
return CreateCriteria<SupportConcept>()
|
|
.Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.LeftOuterJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
|
|
.CreateAlias("p." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
|
|
.CreateAlias("c." + Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> GetAllSupportConceptsCompact()
|
|
{
|
|
return CreateCriteria<SupportConcept>()
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.LeftOuterJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
|
|
.CreateAlias("p." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
|
|
.CreateAlias("c." + Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
public IList<ListedSupportConcept> GetAllActiveAndArchivedListedSupportConceptsCompact()
|
|
{
|
|
return Session.CreateCriteria<ListedSupportConcept>()
|
|
.List<ListedSupportConcept>();
|
|
}
|
|
|
|
public IList<ListedSupportConcept> GetAllActiveAndArchivedListedSupportConceptsCompact(List<long> oids)
|
|
{
|
|
return Session.CreateCriteria<ListedSupportConcept>()
|
|
.Add(Restrictions.In("SupportConceptOid", oids))
|
|
.List<ListedSupportConcept>();
|
|
}
|
|
|
|
public IList<Customer> GetAllCustomerWithServiceRecordsInSpan(DateTimeSpan pSpan)
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.CreateCriteria(Customer.PropertyName_ServiceRecordList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<AccountingTransaction> GetAllAccountingTransactionsWithDetails()
|
|
{
|
|
return CreateCriteria<AccountingTransaction>()
|
|
.AddOrder(Order.Desc(AccountingTransaction.PropertyName_BookingDate))
|
|
.CreateAlias(AccountingTransaction.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.LeftOuterJoin)
|
|
.CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, JoinType.LeftOuterJoin)
|
|
.CreateCriteria(CostBearer.PropertyName_Organisation, JoinType.LeftOuterJoin)
|
|
.CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_SupportConcept, JoinType.LeftOuterJoin)
|
|
.CreateCriteria(SupportConcept.PropertyName_Customer, JoinType.LeftOuterJoin)
|
|
.CreateCriteria(Customer.PropertyName_Person, JoinType.LeftOuterJoin)
|
|
.List<AccountingTransaction>();
|
|
}
|
|
|
|
public IEnumerable<AccountingTransaction> FindAccountingTransactionsWithImportNotice(String notice)
|
|
{
|
|
return CreateCriteria<AccountingTransaction>()
|
|
.Add(Restrictions.Eq(AccountingTransaction.PropertyName_ImportNotice, notice)).List<AccountingTransaction>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> GetAllActiveAndArchivedSupportConcepts()
|
|
{
|
|
return CreateCriteria<SupportConcept>()
|
|
.Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
|
|
.CreateAlias("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
|
|
.CreateAlias("cb." + CostBearer.PropertyName_Organisation, "org", JoinType.InnerJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
|
|
.List<SupportConcept>();
|
|
}
|
|
|
|
public IEnumerable<Customer> GetAllActiveAndArchivedCustomersWithRelatedEmployee()
|
|
{
|
|
return CreateCriteria<Customer>()
|
|
.Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
|
|
.CreateAlias(Customer.PropertyName_Person, "cp", JoinType.InnerJoin)
|
|
.CreateAlias("cp." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
|
|
.CreateAlias(Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
|
|
.CreateAlias("e2c." + Employee2Customer.PropertyName_Employee, "e", JoinType.LeftOuterJoin)
|
|
.CreateCriteria("e2c." + Employee2Customer.PropertyName_ValueList, JoinType.LeftOuterJoin)
|
|
.CreateCriteria("e." + Employee.PropertyName_Person, JoinType.LeftOuterJoin)
|
|
.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<SettlementInvoice> GetSettlementInvoiceBySupportConceptOid(long supportConceptOid)
|
|
{
|
|
return CreateCriteriaIsActive<SettlementInvoice>()
|
|
.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid))
|
|
.List<SettlementInvoice>();
|
|
}
|
|
|
|
public IList<SettlementInvoice> GetSettlementInvoiceByCostBearer2SupportConceptOid(long costBearer2SupportConceptOid)
|
|
{
|
|
return CreateCriteriaIsActive<SettlementInvoice>()
|
|
.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid))
|
|
.List<SettlementInvoice>();
|
|
}
|
|
|
|
public IEnumerable<SettlementInvoice> GetSettlementInvoicesForCostBearerAndPeriod(long costBearerOid, DateTime periodStart, DateTime periodEnd)
|
|
{
|
|
return CreateCriteriaIsActive<SettlementInvoice>()
|
|
.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.CreateAlias("ib." + InvoiceBase.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.InnerJoin)
|
|
.CreateAlias("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("cb." + BeWoEntityBase.PropertyName_Oid, costBearerOid))
|
|
.Add(Restrictions.Or(
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, periodStart, periodEnd),
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, periodStart, periodEnd)))
|
|
.List<SettlementInvoice>();
|
|
}
|
|
|
|
public IList<InvoiceBase> GetInvoiceBaseByTypeAndSupportConceptOid(InvoiceType type, long supportConceptOid)
|
|
{
|
|
return SearchInvoiceBase(type, InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid);
|
|
}
|
|
|
|
public IEnumerable<InvoiceBase> GetInvoiceBaseByOrganisationOid(InvoiceType type, long organisationOid)
|
|
{
|
|
return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientOrganisationOid, organisationOid);
|
|
}
|
|
|
|
public IEnumerable<InvoiceBase> GetInvoiceBaseByCustomerOid(InvoiceType type, long customerOid)
|
|
{
|
|
return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientCustomerOid, customerOid);
|
|
}
|
|
|
|
public IEnumerable<InvoiceBase> GetInvoiceBaseByPersonOid(InvoiceType type, long personOid)
|
|
{
|
|
return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientPersonOid, personOid);
|
|
}
|
|
|
|
private IList<InvoiceBase> SearchInvoiceBase(InvoiceType type, string propertyname, long fkOid)
|
|
{
|
|
return CreateCriteriaIsActive<InvoiceBase>()
|
|
.Add(Restrictions.Eq(InvoiceBase.PropertyName_Type, type))
|
|
.Add(Restrictions.Eq(propertyname, fkOid))
|
|
.List<InvoiceBase>();
|
|
}
|
|
|
|
public SettlementInvoice GetSettlementInvoiceByInvoiceBaseOid(long invoiceBaseOid)
|
|
{
|
|
return CreateCriteria<SettlementInvoice>()
|
|
.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_Oid, invoiceBaseOid))
|
|
.UniqueResult<SettlementInvoice>();
|
|
}
|
|
|
|
public ServiceInvoice GetServiceInvoiceByInvoiceBaseOid(long invoiceBaseOid)
|
|
{
|
|
var res = CreateCriteriaIsActive<ServiceInvoice>()
|
|
.CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_Oid, invoiceBaseOid))
|
|
.UniqueResult<ServiceInvoice>();
|
|
|
|
return res;
|
|
}
|
|
|
|
public IEnumerable<AssessmentSheetEntry> GetAssessmentSheetEntriesForCustomer(long customerOid, DateTime startDt, DateTime endDt)
|
|
{
|
|
|
|
|
|
return CreateCriteriaIsActive<AssessmentSheetEntry>()
|
|
.CreateAlias(AssessmentSheetEntry.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
|
|
.Add(Restrictions.Ge(AssessmentSheetEntry.PropertyName_Day, startDt))
|
|
.Add(Restrictions.Lt(AssessmentSheetEntry.PropertyName_Day, endDt))
|
|
.List<AssessmentSheetEntry>();
|
|
}
|
|
|
|
public IList<VarFieldDef> GetVarFieldDefs(TableID tid)
|
|
{
|
|
return CreateCriteriaIsActive<VarFieldDef>()
|
|
.Add(Restrictions.Eq(VarFieldDef.PropertyName_ObjectTid, tid))
|
|
.List<VarFieldDef>();
|
|
}
|
|
|
|
public IEnumerable<Task> FindTasksForEmployee(long employeeoid)
|
|
{
|
|
return CreateCriteriaIsActive<Task>()
|
|
.CreateAlias(Task.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
|
|
.CreateAlias("sc." + SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.CreateCriteria(Task.PropertyName_EmployeeList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeoid))
|
|
.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.List<Task>();
|
|
}
|
|
|
|
public List<ServiceInvoice> GetServiceInvoices(long costBearerOid, long? supportConceptOid, DateTimeSpan period)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<ServiceInvoice>()
|
|
.CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_RecipientCostBearerOid, costBearerOid))
|
|
.Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
|
|
|
|
if(supportConceptOid.HasValue)
|
|
criteria = criteria
|
|
.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid.Value));
|
|
|
|
if(period != null)
|
|
criteria = criteria
|
|
.Add(Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime, period.EndDateTime),
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.StartDateTime, period.EndDateTime)),
|
|
Restrictions.And(
|
|
Restrictions.Le("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime),
|
|
Restrictions.Ge("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.EndDateTime))));
|
|
|
|
return criteria.List<ServiceInvoice>().ToList();
|
|
}
|
|
|
|
public List<ServiceInvoice> GetServiceInvoices(long? costbearer2SupportConceptOid, DateTimeSpan period)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<ServiceInvoice>()
|
|
.CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
|
|
|
|
if(costbearer2SupportConceptOid.HasValue)
|
|
criteria = criteria
|
|
.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConceptOid.Value));
|
|
|
|
|
|
|
|
if(period != null)
|
|
criteria = criteria
|
|
.Add(Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime, period.EndDateTime),
|
|
Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.StartDateTime, period.EndDateTime)),
|
|
Restrictions.And(
|
|
Restrictions.Le("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime),
|
|
Restrictions.Ge("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.EndDateTime))));
|
|
|
|
return criteria.List<ServiceInvoice>().ToList();
|
|
}
|
|
|
|
public IEnumerable<AssessmentSheetCategory> GetAssessmentSheetCategoryListForCustomer(long customerOid)
|
|
{
|
|
|
|
return CreateCriteriaIsActive<AssessmentSheetCategory>()
|
|
.CreateAlias(AssessmentSheetCategory.PropertyName_Customers, "c", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
|
|
.List<AssessmentSheetCategory>();
|
|
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> FindAbsenceTimes(bool fetchEmployees, bool fetchCustomers)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>();
|
|
|
|
if(!fetchEmployees)
|
|
criteria = criteria
|
|
.Add(Restrictions.IsNull(AbsenceTime.PropertyName_EmployeeOid));
|
|
else if(!fetchCustomers)
|
|
criteria = criteria
|
|
.Add(Restrictions.IsNull(AbsenceTime.PropertyName_CustomerOid));
|
|
|
|
return criteria.List<AbsenceTime>().ToList();
|
|
|
|
|
|
}
|
|
|
|
public List<AbsenceTime> FindAbsenceTimes(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Ge(AbsenceTime.PropertyName_End, startDate),
|
|
Restrictions.Lt(AbsenceTime.PropertyName_Start, endDate.Date.AddDays(1))
|
|
),
|
|
Restrictions.And(
|
|
Restrictions.Lt(AbsenceTime.PropertyName_Start, endDate.Date.AddDays(1)),
|
|
Restrictions.IsNull(AbsenceTime.PropertyName_End)
|
|
)
|
|
)
|
|
);
|
|
|
|
return criteria.List<AbsenceTime>().ToList();
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> FindAbsenceTimesForEmployee
|
|
(DateTime startDate, DateTime endDate, long empOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(Restrictions.Eq("EmployeeOid", empOid))
|
|
.Add(Restrictions.Gt(AbsenceTime.PropertyName_Start, startDate))
|
|
.Add(Restrictions.Lt(AbsenceTime.PropertyName_End, endDate));
|
|
|
|
return criteria.List<AbsenceTime>().ToList();
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> FindAbsenceTimesForMonth(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>();
|
|
criteria.Add(Restrictions.Gt("Start", startDate));
|
|
criteria.Add(Restrictions.Lt("End", endDate));
|
|
|
|
return criteria.List<AbsenceTime>().ToList();
|
|
}
|
|
|
|
public IEnumerable<Vertretung> FindVertretungen(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<Vertretung>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Ge(Vertretung.PropertyName_VertretungsZeitraumBis, startDate),
|
|
Restrictions.Le(Vertretung.PropertyName_VertretungsZeitraumVon, endDate)
|
|
),
|
|
Restrictions.And(
|
|
Restrictions.Le(Vertretung.PropertyName_VertretungsZeitraumVon, endDate),
|
|
Restrictions.IsNull(Vertretung.PropertyName_VertretungsZeitraumBis)
|
|
)
|
|
)
|
|
);
|
|
|
|
return criteria.List<Vertretung>().ToList();
|
|
|
|
|
|
}
|
|
|
|
public IEnumerable<Vertretung> FindLastVertretungen(long customerOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Vertretung>();
|
|
c.Add(Restrictions.Eq("CustomerOid", customerOid));
|
|
|
|
return c.List<Vertretung>().ToList();
|
|
|
|
|
|
}
|
|
|
|
public IEnumerable<Appointment> FindAppointments(long? customerOid, long? employeeOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<Appointment>();
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
criteria = criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_EmployeeOid, employeeOid));
|
|
}
|
|
|
|
if(customerOid.HasValue)
|
|
{
|
|
criteria = criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_CustomerOid, customerOid));
|
|
}
|
|
|
|
return criteria.List<Appointment>().ToList();
|
|
}
|
|
|
|
public ServiceCategory FindDefaultIndividualServiceCategory()
|
|
{
|
|
return CreateCriteriaIsActive<ServiceCategory>()
|
|
.Add(Restrictions.Eq(ServiceCategory.PropertyName_ScopeType, ScopeTypeId.Individual))
|
|
.List<ServiceCategory>().FirstOrDefault();
|
|
}
|
|
|
|
public ServiceCategory FindServiceCategoryByName(String name)
|
|
{
|
|
return CreateCriteriaIsActive<ServiceCategory>()
|
|
.Add(Restrictions.Eq(ServiceCategory.PropertyName_Name, name))
|
|
.List<ServiceCategory>().FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<FileAttachmentInfo> FindFileAttachmentInfoByType(FileAttachmentType type)
|
|
{
|
|
var criteria = CreateCriteria<FileAttachmentInfo>()
|
|
.Add(Restrictions.Eq("Type", type));
|
|
|
|
return criteria.List<FileAttachmentInfo>().ToList();
|
|
}
|
|
|
|
public IEnumerable<AssessmentSheetEntry> GetAdditionalAssessmentSheetEntries(DateTime dateTime)
|
|
{
|
|
return CreateCriteria<AssessmentSheetEntry>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_SystemEntryID, SystemEntryID.AdditionalServiceAssessmentSheet))
|
|
.Add(Restrictions.Eq(AssessmentSheetEntry.PropertyName_Day, dateTime.Date))
|
|
.List<AssessmentSheetEntry>();
|
|
}
|
|
|
|
public IEnumerable<ResourceAppointment> GetResourceAppointmentExceptionsWithIndexAndId(string info)
|
|
{
|
|
return CreateCriteria<ResourceAppointment>()
|
|
.Add(Restrictions.Like(ResourceAppointment.PropertyName_RecurrenceInfo, info))
|
|
.List<ResourceAppointment>();
|
|
|
|
}
|
|
|
|
public IEnumerable<AdditionalServiceBooking> GetAdditionalServiceBookings(long? regionOid, DateTime start, DateTime end)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AdditionalServiceBooking>()
|
|
.Add(Restrictions.Between("Datum", start, end));
|
|
|
|
if(regionOid.HasValue)
|
|
criteria = criteria.CreateAlias(AdditionalServiceBooking.PropertyName_AdditionalServiceRegion, "asr", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("asr." + BeWoEntityBase.PropertyName_Oid, regionOid));
|
|
|
|
return criteria.List<AdditionalServiceBooking>();
|
|
}
|
|
|
|
public IEnumerable<AdditionalServiceNotice> GetAdditionalServiceNoticeList(long? regionOid, DateTime start, DateTime end)
|
|
{
|
|
var c = CreateCriteriaIsActive<AdditionalServiceNotice>()
|
|
.Add(Restrictions.Between("Monat", start, end));
|
|
|
|
if(regionOid.HasValue)
|
|
{
|
|
c.Add(Restrictions.Eq("RegionOid", regionOid));
|
|
}
|
|
|
|
return c.List<AdditionalServiceNotice>();
|
|
}
|
|
|
|
public IEnumerable<AdditionalServiceBooking> GetAdditionalServiceBookingsForCustomer(long customerOid, DateTime start, DateTime end)
|
|
{
|
|
return CreateCriteriaIsActive<AdditionalServiceBooking>()
|
|
.CreateAlias(AdditionalServiceBooking.PropertyName_Customer2AddServiceBookings, "c2s", JoinType.InnerJoin)
|
|
.Add(Restrictions.Between("Datum", start, end))
|
|
.Add(Restrictions.Eq("c2s.CustomerOid", customerOid))
|
|
.List<AdditionalServiceBooking>();
|
|
}
|
|
|
|
public AssessmentSheetCategory GetAddServiceAssessmentSheetCategoryWithName(string name)
|
|
{
|
|
return CreateCriteriaIsActive<AssessmentSheetCategory>()
|
|
.Add(Restrictions.Eq(AssessmentSheetCategory.PropertyName_Description, name))
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_SystemEntryID, SystemEntryID.AdditionalServiceAssessmentSheet))
|
|
.List<AssessmentSheetCategory>().FirstOrDefault();
|
|
}
|
|
|
|
public IList<ServiceRecord> GetBillableServiceRecords()
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("sc." + ServiceCategory.PropertyName_IsBillable, true));
|
|
|
|
return c.List<ServiceRecord>();
|
|
}
|
|
|
|
public IList<ServiceRecord> GetBillableServiceRecords(DateTime start, DateTime end)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("sc." + ServiceCategory.PropertyName_IsBillable, true))
|
|
.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, start, end));
|
|
|
|
|
|
return c.List<ServiceRecord>();
|
|
}
|
|
|
|
public IList GetBillableServiceRecordsSqlArray(DateTime start, DateTime end)
|
|
{
|
|
var q = Session.CreateSQLQuery(String.Format(@"
|
|
SELECT sr.Oid, sr.StartDate, sr.EndDate, sr.EmployeeOid, sr.CustomerOid, sr.GroupOid, sr.costbearer2supportconceptoid, sd.Name, sc.Name
|
|
FROM ServiceRecord sr
|
|
inner join ServiceDescription sd on sr.ServiceDescriptionOid = sd.Oid
|
|
inner join ServiceCategory sc on sd.ServiceCategoryOid = sc.Oid
|
|
WHERE sc.Billable = 1 and sr.StartDate >= '{0:yyyy-MM-dd}' and sr.StartDate < '{1:yyyy-MM-dd}'", start, end));
|
|
|
|
return q.List();
|
|
|
|
}
|
|
|
|
public IEnumerable<ServiceDescription> FindServiceDescriptionForCategory(long categoryOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ServiceDescription>()
|
|
.CreateAlias(ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_Oid, categoryOid));
|
|
|
|
return c.List<ServiceDescription>();
|
|
}
|
|
|
|
public IEnumerable<ServiceAccounting> FindServiceAccountingsForServiceDescriptions(IList<long> descriptionOids)
|
|
{
|
|
var c = CreateCriteriaIsActive<ServiceAccounting>()
|
|
.CreateAlias("ServiceDescription", "sd", JoinType.InnerJoin)
|
|
.Add(Restrictions.In("sd." + BeWoEntityBase.PropertyName_Oid, descriptionOids.ToArray()));
|
|
|
|
return c.List<ServiceAccounting>();
|
|
}
|
|
|
|
public IList<Medikamentenverordnungsliste> GetAllMedikamentenverordnungslistenButNewestByCustomerOid(long customerOid, long newestOid, bool isBedarfsListe)
|
|
{
|
|
var c = CreateCriteria<Medikamentenverordnungsliste>()
|
|
.CreateAlias(Medikamentenverordnungsliste.PropertyName_Customer, "c")
|
|
.Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
|
|
.Add(Restrictions.Not(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, newestOid)))
|
|
.Add(Restrictions.Eq(Medikamentenverordnungsliste.PropertyName_MedListType, isBedarfsListe));
|
|
|
|
return c.List<Medikamentenverordnungsliste>();
|
|
}
|
|
|
|
public IList<SchedulerAppointment> GetAllOpenAppointmentsForEmployee(long employeeOid)
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.Add(Restrictions.Not(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid)))
|
|
.Add(Restrictions.Or(Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, DateTime.Now.AddDays(-7)), Restrictions.IsNull(SchedulerAppointment.PropertyName_EndDate)))
|
|
.CreateCriteria(SchedulerAppointment.PropertyName_EmployeeList)
|
|
.Add(Restrictions.And(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid),
|
|
Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Offen)));
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllParticipationNotificationsForEmployee(long employeeOid)
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.And(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid)))
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.Add(Restrictions.Or(Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, DateTime.Now.AddDays(-7)), Restrictions.IsNull(SchedulerAppointment.PropertyName_EndDate)))
|
|
.CreateCriteria(SchedulerAppointment.PropertyName_EmployeeList)
|
|
.Add(Restrictions.And(Restrictions.And(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_IsPChanged, true), Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid))), Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Offen))))
|
|
.Add(Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Verstrichen)))
|
|
.Add(Restrictions.IsNull(Employee2SchedulerAppointment.PropertyName_IsPC_CheckedTs));
|
|
|
|
var result = c.List<SchedulerAppointment>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IEnumerable<Employee2SchedulerAppointment> GetRemovedEmp2AppObjectsBySchAppOid(long schAppOid)
|
|
{
|
|
var c = CreateCriteria<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, schAppOid));
|
|
|
|
return c.List<Employee2SchedulerAppointment>();
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllActiveAndNotDeclinedForEmployeeAppointments(long employeeOid)
|
|
{
|
|
var detachedCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.And(Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid)),
|
|
Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Absage)));
|
|
detachedCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
|
|
var crit = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.Add(Restrictions.Or(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid), Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria)));
|
|
|
|
return crit.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public bool ResetPasswordCodeExists(string code, long userOid)
|
|
{
|
|
var c = CreateCriteria<ApplicationUser>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, userOid))
|
|
.CreateCriteria(ApplicationUser.PropertyName_ResetPasswordInfos)
|
|
.Add(Restrictions.Eq(ResetPasswordInfo.PropertyName_Code, code));
|
|
|
|
return c.List<ApplicationUser>().Count > 0;
|
|
}
|
|
|
|
public bool OverlappingAppointmentsExist(DateTime start, DateTime end, IEnumerable<long> employees, IEnumerable<long> customers, IEnumerable<long> resources, long originator, long? appointmentOid, string recurrenceId = "", int occurrenceIndex = 0)
|
|
{
|
|
if(employees is null)
|
|
{
|
|
employees = new List<long>();
|
|
}
|
|
|
|
if(customers is null)
|
|
{
|
|
customers = new List<long>();
|
|
}
|
|
|
|
if(resources is null)
|
|
{
|
|
resources = new List<long>();
|
|
}
|
|
|
|
var isRecurrenceException = appointmentOid is null;
|
|
var isBeingUpdatedToNormalAppointment = false;
|
|
Guid? recurrenceIdToIgnore = null;
|
|
|
|
if(appointmentOid != null)
|
|
{
|
|
// Das Pattern wird geladen, bzw. mit der Ausnahme mit Index 0 verglichen
|
|
// Wird die Serie in einen Einzeltermin geändert und es existiert eine Ausnahme mit Index 0, sollte die Ausnahme behalten werden und nicht der Root-Termin
|
|
var original = DAOFactory.GenericDAO.LoadByID<SchedulerAppointment>(appointmentOid.Value);
|
|
var ri = original?.GetRecurrenceId();
|
|
if(ri != null && IsNullOrWhiteSpace(recurrenceId))
|
|
{
|
|
isBeingUpdatedToNormalAppointment = true;
|
|
recurrenceIdToIgnore = ri;
|
|
}
|
|
}
|
|
|
|
Guid? recurrenceGuid = null;
|
|
|
|
if(Guid.TryParse(recurrenceId, out var parsedGuid))
|
|
{
|
|
recurrenceGuid = parsedGuid;
|
|
}
|
|
|
|
var betweenDateTimesCriterion = CreateBetweenDateTimesCriterion(start, end, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), false))
|
|
.Add(betweenDateTimesCriterion);
|
|
|
|
if(isRecurrenceException == false)
|
|
{
|
|
criteria.Add(Restrictions.Not(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, appointmentOid)));
|
|
}
|
|
|
|
var appTmp = criteria.List<SchedulerAppointment>();
|
|
|
|
var appointments = appTmp.Where(a =>
|
|
{
|
|
if(a.RecurrenceInfo is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var recId2 = a.GetRecurrenceIdAndIndex(out var index);
|
|
|
|
return !(Guid.TryParse(recurrenceId, out var guid) && guid.Equals(recId2) && occurrenceIndex == index);
|
|
});
|
|
|
|
var schedulerAppointments = appointments as IList<SchedulerAppointment> ?? appointments.ToList();
|
|
|
|
// Serientermine anhand der RecurrenceInfo erzeugen und den schedulerAppointments hinzufügen ------------------------------------------------------------
|
|
var deletedOccurences = schedulerAppointments.Where(app => app.Type == 4).Select(app => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
var changedOccurences = schedulerAppointments.Where(app => app.Type == 3).Select(app => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
|
|
var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));
|
|
|
|
var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().ToList();
|
|
|
|
if(isBeingUpdatedToNormalAppointment)
|
|
{
|
|
recurringAppointments = recurringAppointments.Where(root =>
|
|
{
|
|
var recId = root.GetRecurrenceId();
|
|
|
|
if(recId is null || recurrenceIdToIgnore is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return !recId.Equals(recurrenceIdToIgnore);
|
|
}).ToList();
|
|
|
|
schedulerAppointments = schedulerAppointments.Where(root =>
|
|
{
|
|
var recId = root.GetRecurrenceId();
|
|
|
|
if(recId is null || recurrenceIdToIgnore is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return !recId.Equals(recurrenceIdToIgnore);
|
|
}).ToList();
|
|
}
|
|
|
|
foreach(var appointment in recurringAppointments)
|
|
{
|
|
var recurrenceInfo = new RecurrenceInfo();
|
|
recurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
|
|
var occurenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);
|
|
|
|
// Das Muster für die Terminserie wird berechnet
|
|
var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);
|
|
|
|
if(pattern is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pattern.RecurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
pattern.Start = pattern.RecurrenceInfo.Start;
|
|
pattern.End = appointment.EndDate.Value; //pattern.RecurrenceInfo.End;
|
|
|
|
var patternId = pattern.RecurrenceInfo.Id.ToString();
|
|
|
|
// In diesem Fall die Start- und Enddaten des zu überprüfenden, neuen Termins
|
|
var interval = new TimeInterval(start, end);
|
|
|
|
// Die Serientermine werden berechnet (ausnahmslos, d.h. es werden auch bearbeitete und gelöschte Termine erstellt, die herausgefiltert werden müssen).
|
|
var occurrences = occurenceCalculator.CalcOccurrences(interval, pattern);
|
|
|
|
foreach(var occurrence in occurrences.GetAppointments(interval))
|
|
{
|
|
if(appointment.EndDate is null || appointment.StartDate is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Terminindex in der Serie
|
|
var index = occurrence.RecurrenceIndex;
|
|
|
|
// Das Ende ist offen, da die Terminserie kein Ende hat. Deshalb wird das Ende berechnet.
|
|
var duration = (appointment.EndDate.Value - appointment.StartDate.Value).TotalMinutes;
|
|
|
|
var guidParsingSuccessful = Guid.TryParse(occurrence.RecurrenceInfo?.Id?.ToString(), out var occurrenceGuid);
|
|
|
|
// Der generierte Serientermin muss sich zeitlich mit dem neuen Termin überschneiden
|
|
// und darf nicht in der Liste der geänderten Serientermine oder der Liste der gelöschten Serientermine sein.
|
|
|
|
var isInIntervalTest = start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration));
|
|
|
|
if(!isInIntervalTest ||
|
|
changedOccurences != null && changedOccurences.Any(changedOccurence => changedOccurence.PatternId.Equals(patternId) && changedOccurence.Index == index) ||
|
|
deletedOccurences != null && deletedOccurences.Any(deletedOccurence => deletedOccurence.PatternId.Equals(patternId) && deletedOccurence.Index == index) ||
|
|
index == occurrenceIndex && guidParsingSuccessful && recurrenceGuid != null && recurrenceGuid.Equals(occurrenceGuid))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Prüfen, ob es eine Ausnahme an dem Tag gibt, die zu dem Pattern gehört, um das Pattern auszuschließen
|
|
var relatedAppointments = FindAppointmentsByRecurrenceId(new List<string> { recurrenceInfo.Id.ToString() }, true);
|
|
var relatedAppointmentsInInterval = relatedAppointments.Where(a =>
|
|
{
|
|
if(a.StartDate == null || a.EndDate == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var myStart = a.StartDate.Value.Date;
|
|
var myEnd = a.EndDate.Value.Date;
|
|
|
|
var isInInterval = start.Date.InBetween(myStart.GetShortDateTime(), myEnd, true);
|
|
|
|
return isInInterval && a.Type != 4;
|
|
}).ToList();
|
|
|
|
var hasToStop = false;
|
|
|
|
// Prüfen, ob es sich bei dem Termin für den Überschneidungen gesucht werden, um zu unterscheiden, ob ein Serientermin in einen normalen geändert wird.
|
|
var root = FindRootAppointmentByRecurrenceId(recurrenceInfo.Id.ToString());
|
|
if(root.Oid != null && appointmentOid != null && root.Oid == appointmentOid && root.RecurrenceInfo != null && IsNullOrWhiteSpace(recurrenceId))
|
|
{
|
|
hasToStop = true;
|
|
}
|
|
|
|
// Indices und Ids der RecurrenceInfo vergleichen. Stimmen sie überein, dann wird das generiert Serienelement ignoriert.
|
|
if(occurrence.RecurrenceInfo?.Id != null && !hasToStop)
|
|
{
|
|
if(Guid.TryParse(occurrence.RecurrenceInfo.Id.ToString(), out var guid))
|
|
{
|
|
foreach(var relatedAppointment in relatedAppointmentsInInterval)
|
|
{
|
|
var relatedAppointmentRecurrenceId = relatedAppointment.GetRecurrenceIdAndIndex(out var relatedAppointmentRecurrenceIndex);
|
|
|
|
if(relatedAppointmentRecurrenceId != null)
|
|
{
|
|
if(guid.Equals(relatedAppointmentRecurrenceId) && relatedAppointmentRecurrenceIndex.Equals(occurrence.RecurrenceIndex))
|
|
{
|
|
hasToStop = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(hasToStop)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var recurringAppointment = new SchedulerAppointment
|
|
{
|
|
AllDay = occurrence.AllDay,
|
|
CustomerList = appointment.CustomerList,
|
|
Notice = appointment.Notice,
|
|
EmployeeList = appointment.EmployeeList,
|
|
EndDate = occurrence.Start.AddMinutes(duration),
|
|
FormerBookingSequenceOid = appointment.FormerBookingSequenceOid,
|
|
IsPrivate = appointment.IsPrivate,
|
|
Location = appointment.Location,
|
|
Originator = appointment.Originator,
|
|
RecurrenceInfo = occurrence.RecurrenceInfo.ToXml(),
|
|
ReminderInfo = appointment.ReminderInfo,
|
|
ResourceList = appointment.ResourceList,
|
|
StartDate = occurrence.Start,
|
|
Subject = appointment.Subject ?? "",
|
|
Type = appointment.Type
|
|
};
|
|
|
|
schedulerAppointments.AddIfNotIn(recurringAppointment);
|
|
}
|
|
}
|
|
// --------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Falls es sich um eine Ausnahme einer Serie handelt, muss die Serie ignoriert werden
|
|
var shouldIgnoreAppointment = false;
|
|
if(isRecurrenceException && recurrenceId != null)
|
|
{
|
|
if(recurrenceGuid.HasValue)
|
|
{
|
|
shouldIgnoreAppointment = true;
|
|
}
|
|
}
|
|
|
|
var employeeOidList = new List<long>();
|
|
|
|
schedulerAppointments = schedulerAppointments.Where(appointment => appointment.Type != 4).ToList();
|
|
|
|
foreach(var appointment in schedulerAppointments)
|
|
{
|
|
if(shouldIgnoreAppointment)
|
|
{
|
|
if(!ShouldDoAppointmentOverlappingCheck(appointment, recurrenceGuid.Value))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
employeeOidList.AddRange(appointment.EmployeeList.Select(rel => rel.ParticipationAnswer != ParticipationAnswer.Absage && rel.Employee.Oid != null ? rel.Employee.Oid.Value : 0));
|
|
}
|
|
|
|
var hasOverlappingEmployeeAppointments = employeeOidList.Intersect(employees).Any();
|
|
var hasOverlappingCustomerAppointments = schedulerAppointments.Any(app => { return ShouldDoAppointmentOverlappingCheck(app, recurrenceGuid) && app.CustomerList.Select(c => c.Oid ?? 0).Intersect(customers).Any(); });
|
|
|
|
var hasOverlappingResourceAppointments = schedulerAppointments.Any(app => { return ShouldDoAppointmentOverlappingCheck(app, recurrenceGuid) && app.ResourceList.Select(r => r.Oid ?? 0).Intersect(resources).Any(); });
|
|
|
|
var hasOverlappingOriginatorAppointments = schedulerAppointments.Any(appointment =>
|
|
{
|
|
if(!ShouldDoAppointmentOverlappingCheck(appointment, recurrenceGuid))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return appointment.Originator.Oid.HasValue &&
|
|
appointment.Originator.Oid.Value == originator &&
|
|
(appointment.EmployeeList.Count == 0 || appointment.EmployeeList.Any(a => a.Employee.Oid.HasValue && a.Employee.Oid.Value == originator));
|
|
});
|
|
|
|
return hasOverlappingEmployeeAppointments || hasOverlappingCustomerAppointments || hasOverlappingResourceAppointments || hasOverlappingOriginatorAppointments;
|
|
}
|
|
|
|
private static bool ShouldDoAppointmentOverlappingCheck(SchedulerAppointment appointment, Guid? recurrenceId)
|
|
{
|
|
if(!appointment.Oid.HasValue || !recurrenceId.HasValue)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var recId = appointment.GetRecurrenceIdAndIndex(out var recIndex);
|
|
|
|
if(appointment.RecurrenceInfo is null || recId is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return !recId.Equals(recurrenceId);
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsForEmployeeInInterval(DateTime start, DateTime end, long pEmployeeOid)
|
|
{
|
|
var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";
|
|
|
|
var criteria = CreateRecurrenceCriteria(start, end)
|
|
.Add(Restrictions.Or(
|
|
Expression.Sql(new SqlString(hasResources)),
|
|
CreateOwnAppointmentsCriteria(pEmployeeOid)));
|
|
|
|
return criteria.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsInInterval(DateTime start, DateTime end)
|
|
{
|
|
return CreateRecurrenceCriteria(start, end).List<SchedulerAppointment>();
|
|
}
|
|
|
|
public ResourceBooking GetFirstResourceBookingFromSequence(long sequenceOid)
|
|
{
|
|
return CreateCriteria<ResourceBooking>()
|
|
.Add(Restrictions.Eq(ResourceBooking.PropertyName_SequencePosition, 0))
|
|
.CreateAlias(ResourceBooking.PropertyName_Sequence, "s")
|
|
.Add(Restrictions.Eq("s." + BeWoEntityBase.PropertyName_Oid, sequenceOid)).UniqueResult<ResourceBooking>();
|
|
}
|
|
|
|
public List<int> GetExcludedBookingSequencePositions(long sequenceOid)
|
|
{
|
|
var c = CreateCriteria<ResourceBooking>()
|
|
.Add(Restrictions.Gt(ResourceBooking.PropertyName_SequencePosition, 0))
|
|
.CreateAlias(ResourceBooking.PropertyName_Sequence, "s")
|
|
.Add(Restrictions.Eq("s." + BeWoEntityBase.PropertyName_Oid, sequenceOid)).List<ResourceBooking>();
|
|
|
|
return c.Select(s => s.SequencePosition).ToList();
|
|
}
|
|
|
|
public IEnumerable<InvoiceBase> GetInvoiceBases(DateTime? startDate, DateTime? endDate, bool useInvoiceDate = true)
|
|
{
|
|
var lCriteria = CreateCriteriaIsActive<InvoiceBase>();
|
|
if(useInvoiceDate)
|
|
{
|
|
if(startDate.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_InvoiceDate, startDate));
|
|
if(endDate.HasValue)
|
|
lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_InvoiceDate, endDate));
|
|
}
|
|
else
|
|
{
|
|
if(startDate.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_AccountingPeriodEnd, startDate));
|
|
if(endDate.HasValue)
|
|
lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_AccountingPeriodStart, endDate));
|
|
}
|
|
|
|
return lCriteria.List<InvoiceBase>();
|
|
}
|
|
|
|
public IEnumerable<GkvAbrechnung> GetGkvAbrechnungen(DateTime? startDate, DateTime? endDate, bool useInvoiceDate = true)
|
|
{
|
|
if(endDate.HasValue)
|
|
endDate = endDate.Value.Date.AddDays(1).AddMilliseconds(-1);
|
|
|
|
var lCriteria = CreateCriteriaIsActive<GkvAbrechnung>();
|
|
if(useInvoiceDate)
|
|
{
|
|
if(startDate.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(nameof(GkvAbrechnung.ErstelltAm), startDate));
|
|
if(endDate.HasValue)
|
|
lCriteria.Add(Restrictions.Le(nameof(GkvAbrechnung.ErstelltAm), endDate));
|
|
}
|
|
else
|
|
{
|
|
if(startDate.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(nameof(GkvAbrechnung.AbrechnungsZeitraumEnde), startDate));
|
|
if(endDate.HasValue)
|
|
lCriteria.Add(Restrictions.Le(nameof(GkvAbrechnung.AbrechnungsZeitraumStart), endDate));
|
|
}
|
|
|
|
return lCriteria.List<GkvAbrechnung>();
|
|
}
|
|
|
|
public IEnumerable<GkvTransferProtokoll> GetGkvTransferProtokollByDateRange(DateTime? start, DateTime? end)
|
|
{
|
|
var lCriteria = CreateCriteria<GkvTransferProtokoll>();
|
|
|
|
if(start.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(nameof(GkvTransferProtokoll.ErstelltAm), start));
|
|
if(end.HasValue)
|
|
lCriteria.Add(Restrictions.Le(nameof(GkvTransferProtokoll.ErstelltAm), end));
|
|
|
|
return lCriteria.List<GkvTransferProtokoll>();
|
|
}
|
|
|
|
public IEnumerable<InvoiceBase> GetInvoiceBases(DateTime? startDate, DateTime? endDate, long costBearerOid, String invoiceId)
|
|
{
|
|
var lCriteria = CreateCriteriaIsActive<InvoiceBase>();
|
|
|
|
if(startDate.HasValue)
|
|
lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_InvoiceDate, startDate));
|
|
|
|
if(endDate.HasValue)
|
|
lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_InvoiceDate, endDate));
|
|
|
|
lCriteria.Add(Restrictions.Eq(InvoiceBase.PropertyName_InvoiceId, invoiceId));
|
|
|
|
lCriteria.CreateAlias(InvoiceBase.PropertyName_CostBearer2SupportConcept, "c2s");
|
|
lCriteria.CreateAlias("c2s." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb");
|
|
lCriteria.Add(Restrictions.Eq("cb.Oid", costBearerOid));
|
|
lCriteria.Add(Restrictions.Eq("c2s.CostBearer.Oid", costBearerOid));
|
|
|
|
return lCriteria.List<InvoiceBase>();
|
|
}
|
|
|
|
public IEnumerable<SupportConcept> GetAllActiveSupportConceptsByCustomers(List<long> customerOids, bool expiredOnesToo = false)
|
|
{
|
|
var c = CreateCriteria<SupportConcept>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c")
|
|
.Add(Restrictions.In("c." + BeWoEntityBase.PropertyName_Oid, customerOids));
|
|
|
|
if(expiredOnesToo)
|
|
{
|
|
|
|
}
|
|
|
|
return c.List<SupportConcept>();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindServiceRecordsForDays(long? costBearer2SupportConceptOid, int dayCount, long? employeeOid)
|
|
{
|
|
var minStart = DateTime.Now.GetShortDateTime().AddDays(-dayCount);
|
|
var c = CreateCriteriaIsActive<ServiceRecord>();
|
|
|
|
if(costBearer2SupportConceptOid.HasValue)
|
|
{
|
|
c.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
|
|
}
|
|
else
|
|
{
|
|
c.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
}
|
|
|
|
if(dayCount > 0)
|
|
{
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minStart));
|
|
}
|
|
|
|
return c.List<ServiceRecord>();
|
|
}
|
|
|
|
public IEnumerable<TextModule> GetActiveTextModuleByServiceCategory(long pServiceCategoryOid)
|
|
{
|
|
var c = CreateCriteria<TextModule>();
|
|
|
|
c.Add(Restrictions.Or(Restrictions.Eq(TextModule.PropertyName_ServiceCategory + ".Oid", pServiceCategoryOid), Restrictions.IsNull(TextModule.PropertyName_ServiceCategory)));
|
|
|
|
return c.List<TextModule>();
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsForEmployeeInInterval2(DateTime start, DateTime end, List<long> pEmployeeOids)
|
|
{
|
|
var mainCriteria = CreateRecurrenceCriteria(start, end);
|
|
|
|
var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pEmployeeOids))
|
|
.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);
|
|
|
|
var originatorCrit = Restrictions.In(SchedulerAppointment.PropertyName_Originator, pEmployeeOids);
|
|
|
|
var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
|
|
.SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid))
|
|
.Add(Restrictions.EqProperty("e2s2." + Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, "sa.Oid"));
|
|
|
|
var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);
|
|
|
|
var and = Restrictions.And(originatorCrit, employee2SchedCrit2);
|
|
|
|
ICriterion employeeCriterion = Restrictions.Or(employee2SchedCrit, and);
|
|
|
|
mainCriteria.Add(employeeCriterion);
|
|
|
|
var appointments = mainCriteria.List<SchedulerAppointment>();
|
|
|
|
var exceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null && w.Type == 3).ToList();
|
|
|
|
var exceptionIds = new List<long>();
|
|
var regex = new Regex("(Id=\\\"[a-z0-9-]+\\\")");
|
|
|
|
foreach(var appointment in exceptionalRecurrenceInfos)
|
|
{
|
|
var match = regex.Match(appointment.RecurrenceInfo);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
var id = actualId[1];
|
|
|
|
if(!appointments.Any(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Contains(id) && w.Type == 1))
|
|
{
|
|
exceptionIds.Add(appointment.Oid.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var exceptionsToModify = appointments.Where(w => w.Oid.HasValue && exceptionIds.Contains(w.Oid.Value)).ToList();
|
|
|
|
foreach(var exception in exceptionsToModify)
|
|
{
|
|
var replacingAppointment = new SchedulerAppointment
|
|
{
|
|
Oid = exception.Oid.Value * -1,
|
|
Version = 1,
|
|
Type = 4,
|
|
RecurrenceInfo = exception.RecurrenceInfo,
|
|
Originator = exception.Originator,
|
|
EmployeeList = exception.EmployeeList,
|
|
CustomerList = exception.CustomerList,
|
|
ResourceList = exception.ResourceList
|
|
};
|
|
|
|
exception.RecurrenceInfo = null;
|
|
exception.Type = 0;
|
|
|
|
appointments.Add(replacingAppointment);
|
|
}
|
|
|
|
var recurrenceIds = new List<string>();
|
|
|
|
var allExceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null);
|
|
foreach(var appointment in allExceptionalRecurrenceInfos)
|
|
{
|
|
var match = regex.Match(appointment.RecurrenceInfo);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
recurrenceIds.AddIfNotIn(actualId[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
var changedOrDeletedOccurences = FindAppointmentsByRecurrenceId(recurrenceIds, true);
|
|
|
|
appointments.AddRangeIfElementsNotIn(changedOrDeletedOccurences);
|
|
|
|
return appointments;
|
|
}
|
|
|
|
public IEnumerable<long> FilterEmployeesWithAppointments(List<long> pEmployeeOids, DateTime pStartTime, DateTime pEndTime)
|
|
{
|
|
if(pEmployeeOids == null)
|
|
{
|
|
pEmployeeOids = new List<long>();
|
|
}
|
|
|
|
var result = new List<long>();
|
|
var appointments = GetAllActiveAppointmentsForEmployeeInInterval2(pStartTime, pEndTime, pEmployeeOids) ?? new List<SchedulerAppointment>();
|
|
var gefilterteTermine =
|
|
appointments.Where(w => w.EmployeeList != null && w.EmployeeList
|
|
.Select(s => s.Employee.Oid.Value)
|
|
.Intersect(pEmployeeOids).Any() || !w.EmployeeList.Select(s => s.Employee.Oid.Value)
|
|
.Intersect(pEmployeeOids).Any() && pEmployeeOids.Contains(w.Originator.Oid.Value)).ToList();
|
|
|
|
var employee2SchedulerAppointmentsList = gefilterteTermine.Select(s => s.EmployeeList).ToList();
|
|
foreach(var employee2SchedulerAppointments in employee2SchedulerAppointmentsList)
|
|
{
|
|
foreach(var employee2SchedulerAppointment in employee2SchedulerAppointments)
|
|
{
|
|
if(employee2SchedulerAppointment.Employee.Oid.HasValue && !result.Contains(employee2SchedulerAppointment.Employee.Oid.Value))
|
|
{
|
|
result.Add(employee2SchedulerAppointment.Employee.Oid.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach(var originator in gefilterteTermine.Select(s => s.Originator))
|
|
{
|
|
if(originator.Oid.HasValue && !result.Contains(originator.Oid.Value))
|
|
{
|
|
result.Add(originator.Oid.Value);
|
|
}
|
|
}
|
|
|
|
var c = CreateCriteria<AbsenceTime>()
|
|
.Add(Restrictions.In(AbsenceTime.PropertyName_EmployeeOid, pEmployeeOids))
|
|
.Add(Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(AbsenceTime.PropertyName_Start, pStartTime),
|
|
Restrictions.Eq(AbsenceTime.PropertyName_End, pEndTime)),
|
|
Restrictions.And(
|
|
Restrictions.And(
|
|
Restrictions.Lt(AbsenceTime.PropertyName_Start, pStartTime),
|
|
Restrictions.Lt(AbsenceTime.PropertyName_End, pStartTime)),
|
|
Restrictions.Gt(AbsenceTime.PropertyName_End, pEndTime))),
|
|
Restrictions.And(
|
|
Restrictions.Lt(AbsenceTime.PropertyName_Start, pStartTime),
|
|
Restrictions.Gt(AbsenceTime.PropertyName_End, pStartTime))),
|
|
Restrictions.And(
|
|
Restrictions.Gt(AbsenceTime.PropertyName_Start, pStartTime),
|
|
Restrictions.Lt(AbsenceTime.PropertyName_End, pEndTime))));
|
|
|
|
var abwesenheiten = c.List<AbsenceTime>();
|
|
|
|
foreach(var abwesenheit in abwesenheiten)
|
|
{
|
|
result.AddIfNotIn(abwesenheit.EmployeeOid.Value);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public IEnumerable<Task> GetTasksForEmployeeByDate(long employeeOid, DateTime date)
|
|
{
|
|
var c = CreateCriteria<Task>().Add(Restrictions.Between(Task.PropertyName_DueDate, date, date.AddDays(1))).CreateCriteria(Task.PropertyName_EmployeeList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid)).List<Task>();
|
|
|
|
return c;
|
|
}
|
|
|
|
public Wohnheimbuchung GetWohnheimbuchungByWohnheimAndBuchungsdatum(long pWohnheimOid, DateTime pBuchungsdatum)
|
|
{
|
|
var c = CreateCriteriaIsActive<Wohnheimbuchung>();
|
|
|
|
c.Add(Restrictions.Eq(Wohnheimbuchung.PropertyName_Buchungsdatum, pBuchungsdatum))
|
|
.Add(Restrictions.Eq(Format("{0}.Oid", Wohnheimbuchung.PropertyName_Wohnheim), pWohnheimOid));
|
|
|
|
return c.UniqueResult<Wohnheimbuchung>();
|
|
}
|
|
|
|
public List<ServiceRecord> FindWohnheimbuchungsServiceRecords(long pWohnheimbuchungsOid)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_WohnheimbuchungsOid, pWohnheimbuchungsOid));
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public bool CheckIfUserGroupIsLastWithUserGroupEditingRights(List<long> pUserGroupOids)
|
|
{
|
|
var dc = DetachedCriteria.For<UserGroup>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid));
|
|
|
|
var c = CreateCriteriaIsActive<RightRelation>()
|
|
.Add(Restrictions.Not(Restrictions.In(RightRelation.PropertyName_UserGroupOid, pUserGroupOids)))
|
|
.Add(Restrictions.In(RightRelation.PropertyName_RightType, new[] { UserRightType.UserGroupView_View, UserRightType.UserGroupView_Edit, UserRightType.ViewAll, UserRightType.EditAll }))
|
|
.Add(Subqueries.PropertyIn(RightRelation.PropertyName_UserGroupOid, dc));
|
|
|
|
var result = c.List<RightRelation>();
|
|
var nachUserGroupOidSortiert = new Dictionary<long, List<UserRightType>>();
|
|
|
|
foreach(var relation in result)
|
|
{
|
|
nachUserGroupOidSortiert.AddOrUpdateValueInDictionary(relation.UserGroupOid.Value, relation.RightType);
|
|
}
|
|
|
|
var minRights2 = nachUserGroupOidSortiert.Any(intersection =>
|
|
intersection.Value.Contains(UserRightType.UserGroupView_Edit) && intersection.Value.Contains(UserRightType.ViewAll) ||
|
|
intersection.Value.Contains(UserRightType.UserGroupView_Edit) && intersection.Value.Contains(UserRightType.UserGroupView_View) ||
|
|
intersection.Value.Contains(UserRightType.EditAll) && intersection.Value.Contains(UserRightType.ViewAll) ||
|
|
intersection.Value.Contains(UserRightType.EditAll) && intersection.Value.Contains(UserRightType.UserGroupView_View));
|
|
|
|
return minRights2 == false;
|
|
}
|
|
|
|
public ServiceDescription FindServiceDescriptionForWohnheimbuchungsServiceRecord(long pWohnheimbuchungsOid)
|
|
{
|
|
var dc = DetachedCriteria.For<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_WohnheimbuchungsOid, pWohnheimbuchungsOid))
|
|
.SetProjection(Projections.Property(ServiceRecord.PropertyName_ServiceDescription + ".Oid"));
|
|
|
|
var c = CreateCriteriaIsActive<ServiceDescription>()
|
|
.Add(Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, dc)).SetMaxResults(1);
|
|
|
|
return c.List<ServiceDescription>().FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<Bargeldkasse> FindBargeldkasse(TableID objectTid, long objectOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Bargeldkasse>()
|
|
.Add(Restrictions.Eq(Bargeldkasse.PropertyName_ObjectTid, objectTid))
|
|
.Add(Restrictions.Eq(Bargeldkasse.PropertyName_ObjectOid, objectOid));
|
|
|
|
return c.List<Bargeldkasse>().ToList();
|
|
}
|
|
|
|
public IEnumerable<Arbeitszeit> FindArbeitszeiten(TableID objectTid, long objectOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Arbeitszeit>();
|
|
|
|
if(objectTid == TableID.Employee)
|
|
{
|
|
c.Add(Restrictions.Eq(Arbeitszeit.PropertyName_EmployeeOid, objectOid));
|
|
}
|
|
else
|
|
{
|
|
c.Add(Restrictions.Eq("Customer", DAOFactory.GenericDAO.GetByID<Customer>(objectOid)));
|
|
}
|
|
|
|
|
|
return c.List<Arbeitszeit>().ToList();
|
|
}
|
|
|
|
public IList<NotizenKategorie> FindNotizenKategorien(TableID objectTid, long objectOid)
|
|
{
|
|
var c = CreateCriteriaIsActiveOrArchived<NotizenKategorie>()
|
|
.Add(Restrictions.Eq(NotizenKategorie.PropertyName_ObjectTid, objectTid))
|
|
.Add(Restrictions.Eq(NotizenKategorie.PropertyName_ObjectOid, objectOid));
|
|
|
|
return c.List<NotizenKategorie>().ToList();
|
|
}
|
|
|
|
public IEnumerable<MedRecord> FindMedRecordsForCustomer(long pCustomerOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<MedRecord>()
|
|
.Add(Restrictions.Eq(MedRecord.PropertyName_Customer + ".Oid", pCustomerOid));
|
|
|
|
return c.List<MedRecord>().ToList();
|
|
}
|
|
|
|
public IEnumerable<Customer> FindAllChatActiveCustomers()
|
|
{
|
|
var c = CreateCriteriaIsActive<CustomerAPPCode>()
|
|
.Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));
|
|
|
|
var codes = c.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();
|
|
|
|
var c2 = CreateCriteriaIsActive<Customer>()
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes));
|
|
|
|
return c2.List<Customer>();
|
|
}
|
|
|
|
public IEnumerable<Employee2Customer> FindAllChatpartnerEmployee2Customer(long pRecipientOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Employee2Customer>()
|
|
.Add(Restrictions.Eq(Employee2Customer.PropertyName_EmployeeOid, pRecipientOid))
|
|
.Add(Restrictions.Eq(Employee2Customer.PropertyName_Chatpartner, true));
|
|
|
|
return c.List<Employee2Customer>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindAllChatMessages(long senderOid, long empfaengerOid, int maxNachrichten)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)),
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, empfaengerOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, senderOid))))
|
|
.Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid))
|
|
.AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit))
|
|
.SetMaxResults(maxNachrichten);
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindNextChatMessages(long senderOid, long empfaengerOid, int messlateZahl, List<string> list, bool isteam)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>();
|
|
if(!isteam)
|
|
{
|
|
c.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)),
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, empfaengerOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, senderOid)))).Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));
|
|
}
|
|
else
|
|
{
|
|
|
|
c.Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, empfaengerOid));
|
|
}
|
|
|
|
c.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, list)));
|
|
|
|
c.AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit));
|
|
c.SetMaxResults(messlateZahl);
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public int CountChatMessages(int aktuelleZahl, long senderOid, long empfaengerOid, bool isTeam)
|
|
{
|
|
//Zähle hier alle ChatMessages
|
|
int xc;
|
|
if(!isTeam)
|
|
{
|
|
xc =
|
|
Session.QueryOver<ChatMessage>()
|
|
.Where(
|
|
message =>
|
|
message.SenderPersonOid == senderOid && message.EmpfaengerPersonOid == empfaengerOid ||
|
|
message.SenderPersonOid == empfaengerOid && message.EmpfaengerPersonOid == senderOid)
|
|
.RowCount();
|
|
|
|
}
|
|
else
|
|
{
|
|
xc =
|
|
Session.QueryOver<ChatMessage>()
|
|
.Where(
|
|
message =>
|
|
message.TeamOid == empfaengerOid)
|
|
.RowCount();
|
|
}
|
|
|
|
int ergebnis = xc - aktuelleZahl;
|
|
|
|
if(ergebnis < 0)
|
|
ergebnis = 0;
|
|
|
|
return ergebnis;
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindAllChatMessagesFromTeam(long senderOid, long teamOid, int messlateZahl)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, teamOid));
|
|
|
|
c.AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit));
|
|
c.SetMaxResults(messlateZahl);
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindAllEmpfängerChatMessages(long senderOid, long empfaengerOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)));
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindEmpfängerChatMessages(long senderOid, long empfaengerOid, string messageOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)));
|
|
|
|
c.Add(Restrictions.Eq(ChatMessage.PropertyName_MessageId, messageOid));
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public IEnumerable<Employee> FindAllChatActiveEmployees()
|
|
{
|
|
var c = CreateCriteriaIsActive<EmployeeAPPCode>()
|
|
.Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_IsChatAktiv, 1));
|
|
|
|
var codes = c.List<EmployeeAPPCode>().Select(s => s.EmployeeOid.Value).ToArray();
|
|
|
|
var c2 = CreateCriteriaIsActive<Employee>()
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes));
|
|
|
|
return c2.List<Employee>();
|
|
}
|
|
|
|
public bool CheckIfEmployeeIsAllowedToChat(long pPersonOid)
|
|
{
|
|
var employee = FindEmployeeWithPersonOid(pPersonOid);
|
|
|
|
var c = CreateCriteriaIsActive<EmployeeAPPCode>()
|
|
.Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_IsChatAktiv, 1))
|
|
.Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_EmployeeOid, employee.Oid));
|
|
|
|
var codes = c.List<EmployeeAPPCode>().ToArray();
|
|
|
|
return codes.Length > 0;
|
|
}
|
|
|
|
public IEnumerable<EmployeeAPPCode> FindAllEmployeeAppCodes(long employeeoid)
|
|
{
|
|
var c = CreateCriteriaIsActive<EmployeeAPPCode>()
|
|
.Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_EmployeeOid, employeeoid));
|
|
|
|
return c.List<EmployeeAPPCode>();
|
|
}
|
|
|
|
public IEnumerable<CustomerAPPCode> FindAllCustomerAppCodes(long customeroid)
|
|
{
|
|
var c = CreateCriteriaIsActive<CustomerAPPCode>()
|
|
.Add(Restrictions.Eq(CustomerAPPCode.PropertyName_CustomerOid, customeroid));
|
|
|
|
|
|
return c.List<CustomerAPPCode>();
|
|
}
|
|
|
|
public IEnumerable<CustomerAPPCode> FindAllCustomerAppCodeBenutzer(string benutzername)
|
|
{
|
|
var c =
|
|
CreateCriteriaIsActive<CustomerAPPCode>()
|
|
.Add(Restrictions.Eq(CustomerAPPCode.PropertyName_Benutzername, benutzername));
|
|
|
|
return c.List<CustomerAPPCode>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindAllChatMessagesForAndroid(long pSenderOid, long pRecipientOid, List<string> pExceptions, bool pForTeam)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pSenderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid)),
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pRecipientOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pSenderOid))))
|
|
.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)))
|
|
.Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));
|
|
|
|
if(pForTeam)
|
|
{
|
|
c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, pRecipientOid))
|
|
.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));
|
|
}
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
//public IEnumerable<ChatMessage> FindAllUnreadChatMessages(List<long> pExceptions)
|
|
//{
|
|
// var c = CreateCriteriaIsActive<ChatMessage>()
|
|
// .Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));
|
|
|
|
// return c.List<ChatMessage>();
|
|
//}
|
|
|
|
public Dictionary<Person, bool> FindAllChatAuthorizedPersonsForEmployee(long pEmployeeOid)
|
|
{
|
|
var result = new Dictionary<Person, bool>();
|
|
|
|
var employee = CreateCriteriaIsActive<Employee>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pEmployeeOid)).UniqueResult<Employee>();
|
|
|
|
var relatedCustomerOids = employee.Employee2CustomerList.Select(s => s.CustomerOid.Value);
|
|
|
|
var c1 = CreateCriteriaIsActive<CustomerAPPCode>()
|
|
.Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));
|
|
var codes = c1.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();
|
|
var c2 = CreateCriteriaIsActive<Customer>()
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes))
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, relatedCustomerOids.ToList()));
|
|
|
|
var customers = c2.List<Customer>();
|
|
var employees = FindAllChatActiveEmployees();
|
|
|
|
employees.DoForEach(d => result.Add(d.Person, true));
|
|
customers.DoForEach(d => result.Add(d.Person, false));
|
|
|
|
return result;
|
|
}
|
|
|
|
public Dictionary<long, byte[]> FindImagesForChatAuthorizedPersonsForEmployee(long pEmployeeOid)
|
|
{
|
|
var result = new Dictionary<long, byte[]>();
|
|
|
|
var employee = CreateCriteriaIsActive<Employee>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pEmployeeOid)).UniqueResult<Employee>();
|
|
|
|
var relatedCustomerOids = employee.Employee2CustomerList.Select(s => s.CustomerOid.Value);
|
|
|
|
var c1 = CreateCriteriaIsActive<CustomerAPPCode>()
|
|
.Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));
|
|
var codes = c1.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();
|
|
var c2 = CreateCriteriaIsActive<Customer>()
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes))
|
|
.Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, relatedCustomerOids.ToList()));
|
|
|
|
var customers = c2.List<Customer>();
|
|
var employees = FindAllChatActiveEmployees();
|
|
|
|
//foreach (var customer in customers.Where(w => w.CustomerImage != null))
|
|
//{
|
|
// result.Add(customer.Person.Oid.Value, customer.CustomerImage);
|
|
//}
|
|
|
|
//foreach (var emp in employees.Where(w => w.EmployeeImage != null))
|
|
//{
|
|
// result.Add(emp.Person.Oid.Value, emp.EmployeeImage);
|
|
//}
|
|
|
|
return result;
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindUnreadChatMessagesForRecipient(long pRecipientOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid))
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_IstGelesen, 0));
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> FindNewestChatMessages(long pRecipientPersonOid)
|
|
{
|
|
var blubb = FindTeamsOfEmployee(pRecipientPersonOid);
|
|
|
|
var c = CreateCriteria<ChatMessage>();
|
|
c.Add(Subqueries.PropertyIn("Oid",
|
|
DetachedCriteria.For<NewestChatMessage>()
|
|
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Or(
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid),
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pRecipientPersonOid)),
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, false)),
|
|
Restrictions.And(Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, true), Restrictions.In(NewestChatMessage.PropertyName_RecipientPersonOid, blubb.Select(s => s.Oid.Value).ToArray())))
|
|
)
|
|
|
|
.SetProjection(Projections.Property("ChatMessageOid"))));
|
|
|
|
var query = ToSql(c);
|
|
|
|
return c.List<ChatMessage>();
|
|
}
|
|
|
|
public static string ToSql(ICriteria criteria)
|
|
{
|
|
var criteriaImpl = (CriteriaImpl) criteria;
|
|
var sessionImpl = (SessionImpl) criteriaImpl.Session;
|
|
var factory = (ISessionFactoryImplementor) sessionImpl.SessionFactory;
|
|
var implementors = factory.GetImplementors(criteriaImpl.EntityOrClassName);
|
|
|
|
if(implementors.Length == 0)
|
|
{
|
|
return "No entity or class name found!";
|
|
}
|
|
|
|
var loader = new CriteriaLoader((IOuterJoinLoadable) factory.GetEntityPersister(implementors[0]), factory, criteriaImpl, implementors[0], sessionImpl.EnabledFilters);
|
|
|
|
return loader.SqlString.ToString();
|
|
}
|
|
|
|
public IEnumerable<string> FindChatMessageIds(List<string> messageIds)
|
|
{
|
|
var c = CreateCriteria<ChatMessage>()
|
|
.Add(Restrictions.In(ChatMessage.PropertyName_MessageId, messageIds));
|
|
|
|
var liste = c.List<ChatMessage>();
|
|
|
|
return liste.Select(s => s.MessageId);
|
|
}
|
|
|
|
public IEnumerable<ChatMessage> LoadChatMessagesChunkwise(string pMessageId, long pRecipientOid, long pSenderOid, bool pForTeam, List<string> pExceptions, bool pIsInitialCall)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pSenderOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid)),
|
|
Restrictions.And(
|
|
Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pRecipientOid),
|
|
Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pSenderOid))));
|
|
|
|
c.Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));
|
|
|
|
if(pForTeam)
|
|
{
|
|
c = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, pRecipientOid));
|
|
}
|
|
|
|
if(!IsNullOrEmpty(pMessageId))
|
|
{
|
|
var c1 = CreateCriteriaIsActive<ChatMessage>()
|
|
.Add(Restrictions.Eq(ChatMessage.PropertyName_MessageId, pMessageId))
|
|
.AddOrder(Order.Desc(BeWoEntityBase.PropertyName_InsTs));
|
|
|
|
var list = c1.List<ChatMessage>();
|
|
if(list.Count > 0)
|
|
{
|
|
var lastLoadedChatMessage = c1.List<ChatMessage>().First();
|
|
|
|
c.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));
|
|
|
|
if(pIsInitialCall)
|
|
{
|
|
c.Add(Restrictions.Gt(BeWoEntityBase.PropertyName_InsTs, lastLoadedChatMessage.InsTs));
|
|
}
|
|
}
|
|
}
|
|
|
|
c.AddOrder(Order.Desc(BeWoEntityBase.PropertyName_InsTs));
|
|
c.SetMaxResults(50);
|
|
|
|
var sqlQeury = ToSql(c);
|
|
|
|
var result = c.List<ChatMessage>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<ChatMediaMessage> GetChatMediaMessagesForChatMessage(long chatMessageOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatMediaMessage>()
|
|
.Add(Restrictions.Eq(ChatMediaMessage.PropertyName_ChatMessageOid, chatMessageOid));
|
|
|
|
return c.List<ChatMediaMessage>();
|
|
}
|
|
|
|
public NewestChatMessage GetNewestChatMessageForConversation(long pRecipientPersonOid, long pSenderPersonOid, bool pIsTeam)
|
|
{
|
|
var teams = new List<long>();
|
|
|
|
if(pIsTeam)
|
|
{
|
|
var employee = FindEmployeeWithPersonOid(pSenderPersonOid);
|
|
if(employee != null)
|
|
{
|
|
teams.AddRange(FindTeamsOfEmployee(employee.Oid.Value).Select(s => s.Oid.Value));
|
|
}
|
|
}
|
|
|
|
var c = CreateCriteria<NewestChatMessage>();
|
|
|
|
if(pIsTeam)
|
|
{
|
|
c.Add(Restrictions.And(Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, true),
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid)));
|
|
}
|
|
else
|
|
{
|
|
c.Add(
|
|
Restrictions.And(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid),
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pSenderPersonOid)),
|
|
Restrictions.And(
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pSenderPersonOid),
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pRecipientPersonOid))),
|
|
|
|
Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, false)));
|
|
}
|
|
|
|
return c.UniqueResult<NewestChatMessage>();
|
|
}
|
|
|
|
public IList<Organisation> GetAllOrganisation2PersonRelations(long personOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Person>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, personOid)).UniqueResult<Person>().Organisation2Persons.Select(s => s.Organisation).ToList();
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
public IList<Person> GetAllPerson2OrganisationRelations(long organisationOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Organisation>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, organisationOid)).UniqueResult<Organisation>().Organisation2PersonList.Select(s => s.Person).ToList();
|
|
|
|
return c;
|
|
}
|
|
|
|
public ServiceRecord FindServiceRecordforHistory(long? pServiceRecordOid)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pServiceRecordOid));
|
|
|
|
return c.UniqueResult<ServiceRecord>();
|
|
}
|
|
|
|
public ArbeitszeitListe FindEmployeeArbeitszeitListe(long employeeOid)
|
|
{
|
|
var c = CreateCriteria<Arbeitszeit>().Add(Restrictions.Eq(Arbeitszeit.PropertyName_EmployeeOid, employeeOid));
|
|
|
|
List<long> nAr = new List<long>();
|
|
|
|
|
|
foreach(var item in c.List<Arbeitszeit>())
|
|
{
|
|
nAr.Add(item.Oid.Value);
|
|
}
|
|
|
|
ArbeitszeitListe a = new ArbeitszeitListe();
|
|
a.Arbeitszeit = c.List<Arbeitszeit>().ToList();
|
|
|
|
if(nAr.Count != 0)
|
|
{
|
|
var cEintrag =
|
|
CreateCriteria<ArbeitszeitEintrag>()
|
|
.Add(Restrictions.In(ArbeitszeitEintrag.PropertyName_ArbeitszeitOid, nAr));
|
|
|
|
|
|
|
|
a.ArbeitszeitEintrag = cEintrag.List<ArbeitszeitEintrag>().ToList();
|
|
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
public IList<SupportConcept> FindCostBearer2SupportConceptForDate(DateTime datum)
|
|
{
|
|
var c = CreateCriteriaIsActive<SupportConcept>();
|
|
|
|
return c
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.Add(Restrictions.Or(
|
|
Restrictions.And(Restrictions.Le("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate, datum), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, datum)),
|
|
Restrictions.And(Restrictions.Le("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum))))
|
|
.List<SupportConcept>().Distinct().ToList();
|
|
}
|
|
|
|
public IList<SupportConcept> FindSupportConceptsInDateRange(bool auchArchivierteHolen, DateTime start, DateTime end)
|
|
{
|
|
ICriteria c = null;
|
|
if(auchArchivierteHolen)
|
|
{
|
|
c = CreateCriteriaIsActiveOrArchived<SupportConcept>();
|
|
}
|
|
else
|
|
{
|
|
c = CreateCriteriaIsActive<SupportConcept>();
|
|
}
|
|
|
|
|
|
return c
|
|
.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
|
|
.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
|
|
.Add(
|
|
Restrictions.Or(Restrictions.And(
|
|
Restrictions.And(Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate), Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate)),
|
|
Restrictions.And(Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate), Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate))),
|
|
Restrictions.Or(
|
|
Restrictions.And(Restrictions.Lt("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate, end), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, start)),
|
|
Restrictions.And(Restrictions.Lt("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate, end), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, start)))))
|
|
.List<SupportConcept>().Distinct().ToList();
|
|
}
|
|
|
|
public IList<QuittierungsCheck> FindQuittierungsCheckWithCustomerOids(List<long> oids)
|
|
{
|
|
var c = CreateCriteria<QuittierungsCheck>()
|
|
.Add(Restrictions.In(QuittierungsCheck.PropertyName_CustomerOid, oids))
|
|
.List<QuittierungsCheck>();
|
|
|
|
return c;
|
|
}
|
|
|
|
public IList<QuittierungsCheck> FindQuittierungsCheckWithCustomerOid(long oid)
|
|
{
|
|
|
|
var c = CreateCriteria<QuittierungsCheck>()
|
|
.Add(Restrictions.Eq(QuittierungsCheck.PropertyName_CustomerOid, oid));
|
|
//.UniqueResult<QuittierungsCheck>();
|
|
|
|
|
|
return c.List<QuittierungsCheck>();
|
|
}
|
|
|
|
public IList<Timesheet> FindTimeSheetsForMonth(DateTime monat)
|
|
{
|
|
DateTime start = new DateTime(monat.Year, monat.Month, 1);
|
|
DateTime end = start.AddMonths(1);
|
|
|
|
return CreateCriteria<Timesheet>()
|
|
.Add(Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)))
|
|
.List<Timesheet>();
|
|
}
|
|
|
|
public Timesheet FindEmployeeTimeSheetForMonth(long employeeOid, DateTime monat)
|
|
{
|
|
DateTime start = new DateTime(monat.Year, monat.Month, 1);
|
|
DateTime end = start.AddMonths(1);
|
|
|
|
return CreateCriteria<Timesheet>()
|
|
.Add(Restrictions.Eq("EmployeeOid", employeeOid))
|
|
.Add(Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end),
|
|
Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)))
|
|
.List<Timesheet>().FirstOrDefault();
|
|
}
|
|
|
|
public IList<Timesheet2Mail> FindTimeSheetMails(long timesheetOid, long employeeOid)
|
|
{
|
|
|
|
return CreateCriteria<Timesheet2Mail>()
|
|
.Add(Restrictions.Eq("TimesheetOid", timesheetOid))
|
|
.Add(Restrictions.Eq("EmployeeOid", employeeOid))
|
|
.List<Timesheet2Mail>();
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> GetAllAbsenceTimesInIntervalByEmployee(DateTime start, DateTime end, long pEmployeeOid, bool pHasRightToSeeAllEmployeeAppointments)
|
|
{
|
|
// Wenn das Enddatum null ist, wird das Ende des Intervalls als Enddatum gesetzt (Ist ja eh read-only).
|
|
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(Restrictions.IsNotNull(AbsenceTime.PropertyName_EmployeeOid))
|
|
.Add(Restrictions.Or
|
|
(Restrictions.Or(Restrictions.Or(
|
|
Restrictions.And(Restrictions.Ge(AbsenceTime.PropertyName_Start, start), Restrictions.Le(AbsenceTime.PropertyName_Start, end)),
|
|
Restrictions.Eq(AbsenceTime.PropertyName_Start, start)
|
|
), Restrictions.And(Restrictions.Le(AbsenceTime.PropertyName_Start, start), Restrictions.IsNull(AbsenceTime.PropertyName_End))
|
|
), Restrictions.And(Restrictions.Lt(AbsenceTime.PropertyName_Start, start), Restrictions.Gt(AbsenceTime.PropertyName_End, start)))
|
|
);
|
|
|
|
if(!pHasRightToSeeAllEmployeeAppointments)
|
|
{
|
|
criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_EmployeeOid, pEmployeeOid));
|
|
}
|
|
|
|
return criteria.List<AbsenceTime>();
|
|
}
|
|
|
|
public IEnumerable<TextModule> GetActiveTextModules(bool pShouldOnlyLoadOwnTextModules, bool pHasRightToSeeAll, bool pIsInAdministrationView, long pEmployeeOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<TextModule>();
|
|
|
|
if(pIsInAdministrationView)
|
|
{
|
|
criteria.Add(Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), false));
|
|
}
|
|
else if(!pHasRightToSeeAll)
|
|
{
|
|
criteria.Add(Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), true))
|
|
.Add(Restrictions.Eq(nameof(TextModule.Employee) + "." + nameof(BeWoEntityBase.Oid), pEmployeeOid));
|
|
}
|
|
else
|
|
{
|
|
criteria.Add(
|
|
Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), true),
|
|
Restrictions.Eq(nameof(TextModule.Employee) + "." + nameof(BeWoEntityBase.Oid), pEmployeeOid)),
|
|
Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), false)));
|
|
}
|
|
|
|
return criteria.List<TextModule>();
|
|
}
|
|
|
|
public IEnumerable<TextModule> GetChildTextModules(TextModule textModule)
|
|
{
|
|
var criteria = CreateCriteria<TextModule>();
|
|
|
|
criteria.Add(Restrictions.Eq(nameof(TextModule.Parent), textModule));
|
|
|
|
return criteria.List<TextModule>();
|
|
}
|
|
|
|
public IEnumerable<ChatBewoMessageSync> FindEmployeeChatBewoMessageSync(long oid)
|
|
{
|
|
var c = CreateCriteriaIsActive<ChatBewoMessageSync>()
|
|
.Add(Restrictions.Eq(ChatBewoMessageSync.PropertyName_EmployeeOid, oid));
|
|
|
|
return c.List<ChatBewoMessageSync>();
|
|
}
|
|
|
|
public IList<Customer2Person> FindCustomerPersonRelationsForPerson(long personOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Customer2Person>()
|
|
.CreateCriteria(Customer2Person.PropertyName_Person, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, personOid));
|
|
|
|
return c.List<Customer2Person>();
|
|
}
|
|
|
|
// KALENDER
|
|
public IList<SchedulerAppointment> LoadFilteredAppointments(bool pHasRightToSeeAllEmployeeAppointments, long pEmployeeOid, DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, bool pIncludeInactiveOnes, bool includeTasks)
|
|
{
|
|
var recurrenceBetween = Format("'{0:yyyy-MM-dd} 00:00:00' BETWEEN STR_TO_DATE(SUBSTRING({1}, 24, 19), '%m/%d/%Y %H:%i:%s') AND STR_TO_DATE(SUBSTRING({1}, 50, 19), '%m/%d/%Y %H:%i:%s')", pIntervalStart, SchedulerAppointment.PropertyName_RecurrenceInfo);
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>();
|
|
|
|
if(!pIncludeInactiveOnes)
|
|
{
|
|
criteria.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
|
|
}
|
|
|
|
if(!includeTasks)
|
|
{
|
|
criteria.Add(Restrictions.Or(
|
|
Restrictions.Eq(SchedulerAppointment.PropertyName_IsTask, false),
|
|
Restrictions.IsNull(SchedulerAppointment.PropertyName_IsTask)));
|
|
}
|
|
|
|
criteria.Add(Restrictions.Or(
|
|
Restrictions.And(Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "Range", MatchMode.Anywhere)),
|
|
Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "OccurrenceCount=\"10\"", MatchMode.Anywhere)),
|
|
Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, pIntervalEnd), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, pIntervalStart)),
|
|
Restrictions.And(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo), Expression.Sql(new SqlString(recurrenceBetween)))),
|
|
Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 3), Expression.Sql(new SqlString(recurrenceBetween))))));
|
|
|
|
if(pPrivateAppointmentsOnly)
|
|
{
|
|
criteria.Add(Restrictions.Eq(SchedulerAppointment.PropertyName_IsPrivate, true));
|
|
}
|
|
else
|
|
{
|
|
if(pEmployeesOnly)
|
|
{
|
|
var hasEmployees = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp)";
|
|
criteria.Add(Expression.Sql(hasEmployees));
|
|
}
|
|
|
|
if(pCustomersOnly)
|
|
{
|
|
var hasCustomers = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp)";
|
|
criteria.Add(Expression.Sql(hasCustomers));
|
|
}
|
|
|
|
if(pResourcesOnly)
|
|
{
|
|
var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";
|
|
criteria.Add(Expression.Sql(hasResources));
|
|
}
|
|
|
|
if(pSelectedEmployees.Any())
|
|
{
|
|
var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pSelectedEmployees))
|
|
.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
criteria.Add(Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1));
|
|
}
|
|
|
|
if(pSelectedCustomers.Any())
|
|
{
|
|
var list = "";
|
|
for(var i = 0; i < pSelectedCustomers.Count; i++)
|
|
{
|
|
if(i != pSelectedCustomers.Count - 1)
|
|
{
|
|
list += "" + pSelectedCustomers[i] + ",";
|
|
}
|
|
else
|
|
{
|
|
list += "" + pSelectedCustomers[i];
|
|
}
|
|
}
|
|
|
|
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({list}))";
|
|
criteria.Add(Expression.Sql(blah));
|
|
}
|
|
|
|
if(pSelectedResources.Any())
|
|
{
|
|
var list = "";
|
|
for(var i = 0; i < pSelectedResources.Count; i++)
|
|
{
|
|
if(i != pSelectedResources.Count - 1)
|
|
{
|
|
list += "" + pSelectedResources[i] + ",";
|
|
}
|
|
else
|
|
{
|
|
list += "" + pSelectedResources[i];
|
|
}
|
|
}
|
|
|
|
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({list}))";
|
|
criteria.Add(Expression.Sql(blah));
|
|
}
|
|
}
|
|
|
|
var test = criteria.List<SchedulerAppointment>().ToList();
|
|
|
|
return criteria.List<SchedulerAppointment>();
|
|
}
|
|
|
|
// ToDo: zu anonymisierende Termine nicht herausfiltern! Also sämtliche, aktive Termine mit den ausgewählten Ressourcen laden!
|
|
// KALENDER
|
|
public IEnumerable<SchedulerAppointment> LoadFilteredAppointmentsForEmployee(bool pHasRightToSeeAllEmployeeAppointments, long? pEmployeeOid, DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, bool pIncludeInactiveOnes)
|
|
{
|
|
var mainCriteria = CreateRecurrenceCriteria(pIntervalStart, pIntervalEnd, pIncludeInactiveOnes);
|
|
|
|
ICriterion ownAppointmentCriterion = null;
|
|
ICriterion employeeCriterion = null;
|
|
ICriterion customerCriterion = null;
|
|
ICriterion resourceCriterion = null;
|
|
|
|
if(pEmployeeOid.HasValue)
|
|
{
|
|
ownAppointmentCriterion = CreateOwnAppointmentsCriteria(pEmployeeOid.Value);
|
|
}
|
|
|
|
if(pPrivateAppointmentsOnly)
|
|
{
|
|
mainCriteria.Add(Restrictions.Eq(SchedulerAppointment.PropertyName_IsPrivate, true));
|
|
}
|
|
|
|
if(pEmployeesOnly)
|
|
{
|
|
var hasEmployees = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp)";
|
|
mainCriteria.Add(Expression.Sql(hasEmployees));
|
|
}
|
|
|
|
if(pCustomersOnly)
|
|
{
|
|
var hasCustomers = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp)";
|
|
mainCriteria.Add(Expression.Sql(hasCustomers));
|
|
}
|
|
|
|
if(pResourcesOnly)
|
|
{
|
|
var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";
|
|
mainCriteria.Add(Expression.Sql(hasResources));
|
|
}
|
|
|
|
if(pSelectedEmployees.Any())
|
|
{
|
|
var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pSelectedEmployees))
|
|
.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);
|
|
|
|
var originatorCrit = Restrictions.In(SchedulerAppointment.PropertyName_Originator, pSelectedEmployees);
|
|
|
|
var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
|
|
.SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid))
|
|
.Add(Restrictions.EqProperty("e2s2." + Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, "sa.Oid"));
|
|
|
|
var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);
|
|
|
|
var and = Restrictions.And(originatorCrit, employee2SchedCrit2);
|
|
|
|
employeeCriterion = Restrictions.Or(employee2SchedCrit, and);
|
|
}
|
|
|
|
if(pSelectedCustomers.Any())
|
|
{
|
|
var list = "";
|
|
for(var i = 0; i < pSelectedCustomers.Count; i++)
|
|
{
|
|
if(i != pSelectedCustomers.Count - 1)
|
|
{
|
|
list += "" + pSelectedCustomers[i] + ",";
|
|
}
|
|
else
|
|
{
|
|
list += "" + pSelectedCustomers[i];
|
|
}
|
|
}
|
|
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({list}))";
|
|
customerCriterion = Expression.Sql(blah);
|
|
}
|
|
|
|
if(pSelectedResources.Any())
|
|
{
|
|
var list = "";
|
|
for(var i = 0; i < pSelectedResources.Count; i++)
|
|
{
|
|
if(i != pSelectedResources.Count - 1)
|
|
{
|
|
list += "" + pSelectedResources[i] + ",";
|
|
}
|
|
else
|
|
{
|
|
list += "" + pSelectedResources[i];
|
|
}
|
|
}
|
|
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({list}))";
|
|
resourceCriterion = Expression.Sql(blah);
|
|
}
|
|
|
|
var listOfCriterias = new List<ICriterion>
|
|
{
|
|
employeeCriterion,
|
|
customerCriterion,
|
|
resourceCriterion
|
|
};
|
|
|
|
if(pSelectedResources.Count == 0)
|
|
{
|
|
if(!pHasRightToSeeAllEmployeeAppointments && pSelectedEmployees.Count == 0)
|
|
{
|
|
mainCriteria.Add(ownAppointmentCriterion);
|
|
}
|
|
else
|
|
{
|
|
listOfCriterias.Add(ownAppointmentCriterion);
|
|
}
|
|
}
|
|
|
|
var orCriteria = CreateOrCriteria(listOfCriterias);
|
|
|
|
if(orCriteria != null)
|
|
{
|
|
mainCriteria.Add(orCriteria);
|
|
}
|
|
|
|
var appointments = mainCriteria.List<SchedulerAppointment>();
|
|
|
|
#region Serientermine
|
|
|
|
var exceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null && w.Type == 3).ToList();
|
|
|
|
var exceptionIds = new List<long>();
|
|
|
|
foreach(var appointment in exceptionalRecurrenceInfos)
|
|
{
|
|
var match = RecurrenceIdRegex.Match(appointment.RecurrenceInfo);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
var id = actualId[1];
|
|
|
|
if(!appointments.Any(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Contains(id) && w.Type == 1))
|
|
{
|
|
exceptionIds.Add(appointment.Oid.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Serienausnahmen werden als gelöscht markiert und es wird die RecurrenceInfo entfernt.
|
|
// Der Type wird auf "normal" gesetzt, damit nicht die ganze Serie angezeigt werden muss, die unter Umständen nichts mit den Filterkriterien zu tun hat.
|
|
var exceptionsToModify = appointments.Where(w => w.Oid.HasValue && exceptionIds.Contains(w.Oid.Value)).ToList();
|
|
|
|
foreach(var exception in exceptionsToModify)
|
|
{
|
|
var replacingAppointment = new SchedulerAppointment
|
|
{
|
|
Oid = exception.Oid.Value * -1,
|
|
Version = 1,
|
|
Type = 4,
|
|
RecurrenceInfo = exception.RecurrenceInfo,
|
|
Originator = exception.Originator,
|
|
EmployeeList = exception.EmployeeList,
|
|
CustomerList = exception.CustomerList,
|
|
ResourceList = exception.ResourceList
|
|
};
|
|
|
|
exception.RecurrenceInfo = null;
|
|
exception.Type = 0;
|
|
|
|
appointments.Add(replacingAppointment);
|
|
}
|
|
|
|
// Wenn ein Serientermin bearbeitet wird, sodass er außerhalb des Fetch-Zeitraumes liegt, wird er nicht mehr korrekt angezeigt.
|
|
// Deshalb werden hier alle Ausnahmen von den in der appointments-Collection enthaltenen Terminen mitgeladen.
|
|
var allExceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null);
|
|
|
|
var changedOrDeletedOccurences = FindAppointmentsByRecurrenceId(ExtractRecurrenceIdFromRecurrenceInfo(allExceptionalRecurrenceInfos.Select(s => s.RecurrenceInfo).ToList()), true);
|
|
|
|
appointments.AddRangeIfElementsNotIn(changedOrDeletedOccurences);
|
|
|
|
#endregion
|
|
|
|
var deletedAppointments = appointments.Where(a => a.IsActive != ActivationTypeId.Active).ToList();
|
|
|
|
return appointments;
|
|
}
|
|
|
|
private static ICriterion CreateOrCriteria(IReadOnlyCollection<ICriterion> criterionList)
|
|
{
|
|
ICriterion orCriterion = null;
|
|
|
|
if(criterionList != null && criterionList.Count > 0)
|
|
{
|
|
foreach(var c in criterionList)
|
|
{
|
|
if(c != null)
|
|
{
|
|
orCriterion = orCriterion == null ? c : Restrictions.Or(orCriterion, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
return orCriterion;
|
|
}
|
|
|
|
private static ICriterion CreateOwnAppointmentsCriteria(long pEmployeeOid)
|
|
{
|
|
var detachedCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.And(
|
|
Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pEmployeeOid),
|
|
Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer,
|
|
ParticipationAnswer.Absage))));
|
|
detachedCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
|
|
var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
|
|
ICriterion ownAppointmentCriterion = Restrictions.Or(
|
|
//Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", pEmployeeOid), Subqueries.PropertyNotIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria2)),
|
|
Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", pEmployeeOid),
|
|
Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria));
|
|
|
|
|
|
return ownAppointmentCriterion;
|
|
}
|
|
|
|
private ICriteria CreateRecurrenceCriteria(DateTime start, DateTime end, bool pIncludeInactiveOnes = false, bool excludeTasks = false)
|
|
{
|
|
var recurrenceBetween = Format("'{0:yyyy-MM-dd} 00:00:00' BETWEEN STR_TO_DATE(SUBSTRING({1}, 24, 19), '%m/%d/%Y %H:%i:%s') AND STR_TO_DATE(SUBSTRING({1}, 50, 19), '%m/%d/%Y %H:%i:%s')", start, SchedulerAppointment.PropertyName_RecurrenceInfo);
|
|
var recurrenceAfter = $"'{start:yyyy-MM-dd} 00:00:00' > STR_TO_DATE(SUBSTRING({SchedulerAppointment.PropertyName_RecurrenceInfo}, 24, 19), '%m/%d/%Y %H:%i:%s')";
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>("sa");
|
|
|
|
if(!excludeTasks)
|
|
{
|
|
criteria.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true)));
|
|
}
|
|
|
|
if(!pIncludeInactiveOnes)
|
|
{
|
|
criteria.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
|
|
}
|
|
|
|
criteria.Add(Restrictions.Or(
|
|
Restrictions.And(
|
|
Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "Range", MatchMode.Anywhere)),
|
|
Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "OccurrenceCount=\"10\"", MatchMode.Anywhere)),
|
|
Restrictions.Or(
|
|
Restrictions.Or(
|
|
Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)),
|
|
Restrictions.Or(Restrictions.And(
|
|
Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "End", MatchMode.Anywhere),
|
|
Restrictions.And(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo), Expression.Sql(new SqlString(recurrenceBetween)))
|
|
), Restrictions.And(
|
|
Restrictions.And(
|
|
Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo),
|
|
Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "End", MatchMode.Anywhere))),
|
|
Expression.Sql(recurrenceAfter)))
|
|
),
|
|
Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 3), Expression.Sql(new SqlString(recurrenceBetween))))));
|
|
|
|
return criteria;
|
|
}
|
|
|
|
public IList<SchedulerAppointment> FindDeletedRecurrencesByRecurrenceId(string pRecurrenceId)
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, pRecurrenceId, MatchMode.Anywhere))
|
|
.Add(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 4));
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IList<SchedulerAppointment> FindAppointmentsByRecurrenecInfo(List<string> pRecurrenceInfos, bool pExcludeRootAppointments = false)
|
|
{
|
|
if(pRecurrenceInfos == null || pRecurrenceInfos.Count == 0)
|
|
{
|
|
return new List<SchedulerAppointment>();
|
|
}
|
|
|
|
return FindAppointmentsByRecurrenceId(ExtractRecurrenceIdFromRecurrenceInfo(pRecurrenceInfos), pExcludeRootAppointments);
|
|
}
|
|
|
|
public IList<SchedulerAppointment> FindAppointmentsByRecurrenceId(List<string> pRecurrenceIds, bool pExcludeRootAppointments = false)
|
|
{
|
|
if(pRecurrenceIds == null || pRecurrenceIds.Count == 0)
|
|
{
|
|
return new List<SchedulerAppointment>();
|
|
}
|
|
|
|
var criterionList = new List<ICriterion>();
|
|
|
|
pRecurrenceIds.DoForEach(id => { criterionList.AddIfNotIn(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, id, MatchMode.Anywhere)); });
|
|
|
|
var recurrenceIdOr = CreateOrCriteria(criterionList);
|
|
if(recurrenceIdOr == null)
|
|
{
|
|
return new List<SchedulerAppointment>();
|
|
;
|
|
}
|
|
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
|
|
.Add(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo))
|
|
.Add(recurrenceIdOr);
|
|
|
|
if(pExcludeRootAppointments)
|
|
{
|
|
c.Add(Restrictions.In(nameof(Appointment.Type), new[] { 2, 3, 4 }));
|
|
}
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public SchedulerAppointment FindRootAppointmentByRecurrenceId(string recurrenceId)
|
|
{
|
|
if(Guid.TryParse(recurrenceId, out var guid))
|
|
{
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere))
|
|
.Add(Restrictions.Eq(nameof(Appointment.Type), 1));
|
|
|
|
return criteria.List<SchedulerAppointment>().FirstOrDefault();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public IList<SchedulerAppointment> FindAppointmentsForCustomer(long pCustomerOid)
|
|
{
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({pCustomerOid}))";
|
|
var customerCriterion = Expression.Sql(blah);
|
|
|
|
var c = CreateCriteria<SchedulerAppointment>().Add(customerCriterion);
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IList<SchedulerAppointment> FindAppointmentsForEmployee(long employeeOid)
|
|
{
|
|
var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp WHERE employeeOid IN ({employeeOid}))";
|
|
var ec = Expression.Sql(blah);
|
|
|
|
var c = CreateCriteria<SchedulerAppointment>().Add(ec);
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IList<GroupOfPeople> GroupOfPeopleForSupportConcept(long pCostBearer2SupportConceptOid)
|
|
{
|
|
var c = CreateCriteria<GroupOfPeople>();
|
|
|
|
c.CreateCriteria(GroupOfPeople.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pCostBearer2SupportConceptOid));
|
|
|
|
return c.List<GroupOfPeople>();
|
|
}
|
|
|
|
public IList<CostRatePeriod> FindDefaultHourlyRateCostRatePeriods()
|
|
{
|
|
var c = CreateCriteria<CostRatePeriod>();
|
|
|
|
c.Add(Restrictions.Eq(CostRatePeriod.PropertyName_CostRateType, CostRatePeriodType.HourlyRate))
|
|
.Add(Restrictions.IsNull(CostRatePeriod.PropertyName_ObjectOid));
|
|
|
|
return c.List<CostRatePeriod>();
|
|
}
|
|
|
|
public virtual IList GetSqlResult(string sql)
|
|
{
|
|
var q = Session.CreateSQLQuery(sql);
|
|
return q.List();
|
|
|
|
}
|
|
|
|
public SchedulerAppointment FindRootAppointmentForException(SchedulerAppointmentDC pAppointment)
|
|
{
|
|
if(pAppointment?.RecurrenceInfo == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var match = RecurrenceIdRegex.Match(pAppointment.RecurrenceInfo);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
var id = actualId[1];
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.IsNotNull(nameof(SchedulerAppointment.RecurrenceInfo)))
|
|
.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), id, MatchMode.Anywhere))
|
|
.Add(Restrictions.Eq(nameof(Appointment.Type), 1));
|
|
|
|
var resultList = criteria.List<SchedulerAppointment>();
|
|
|
|
if(resultList == null || resultList.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return resultList.First();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public SchedulerAppointment FindRootAppointmentForException(SchedulerAppointment pAppointment)
|
|
{
|
|
if(pAppointment?.RecurrenceInfo == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var match = RecurrenceIdRegex.Match(pAppointment.RecurrenceInfo);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
var id = actualId[1];
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.IsNotNull(nameof(SchedulerAppointment.RecurrenceInfo)))
|
|
.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), id, MatchMode.Anywhere))
|
|
.Add(Restrictions.Eq(nameof(Appointment.Type), 1));
|
|
|
|
var resultList = criteria.List<SchedulerAppointment>();
|
|
|
|
if(resultList == null || resultList.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return resultList.First();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static List<string> ExtractRecurrenceIdFromRecurrenceInfo(List<string> pRecurrenceInfos)
|
|
{
|
|
var recurrenceIds = new List<string>();
|
|
|
|
foreach(var info in pRecurrenceInfos)
|
|
{
|
|
var match = RecurrenceIdRegex.Match(info);
|
|
if(match.Success)
|
|
{
|
|
var value = match.Value;
|
|
var actualId = value.Split("\"");
|
|
if(actualId.Count > 1)
|
|
{
|
|
recurrenceIds.AddIfNotIn(actualId[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return recurrenceIds;
|
|
}
|
|
|
|
public IList<Task> LoadTasksForConversion(long pEmployeeOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Task>();
|
|
|
|
c.Add(Expression.Sql($"this_.{nameof(BeWoEntityBase.Oid)} NOT IN (SELECT {nameof(SchedulerAppointment.FormerTaskOid)} FROM newschedulerappointment WHERE {nameof(SchedulerAppointment.FormerTaskOid)} IS NOT NULL)"));
|
|
|
|
var result = c.CreateAlias(nameof(Task.SupportConcept), "sc", JoinType.InnerJoin)
|
|
.CreateAlias("sc." + nameof(SupportConcept.Customer), "c", JoinType.InnerJoin)
|
|
.CreateCriteria(nameof(Task.EmployeeList), JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), pEmployeeOid))
|
|
.Add(Restrictions.Eq("sc." + nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
|
|
.Add(Restrictions.Eq("c." + nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
|
|
.List<Task>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<SchedulerAppointment> LoadTaskAppointmentsForEmployee(long pEmployee, bool hideCompletedTasks)
|
|
{
|
|
var c = CreateCriteriaIsActive<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true));
|
|
|
|
if(hideCompletedTasks)
|
|
{
|
|
c.Add(Restrictions.IsNull(nameof(SchedulerAppointment.CompletedDate)));
|
|
}
|
|
|
|
var employeeListRelationCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", new List<long> { pEmployee }))
|
|
.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
|
|
|
|
var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, employeeListRelationCriteria);
|
|
|
|
c.Add(employee2SchedCrit);
|
|
|
|
var result = c.List<SchedulerAppointment>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<SchedulerAppointment> GetTasksForEmployeeBySupportConcept(long pEmployeeOid, long pSupportConceptOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<SchedulerAppointment>();
|
|
|
|
var employeeListRelationCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(nameof(Employee2SchedulerAppointment.Employee) + ".Oid", new List<long> { pEmployeeOid }))
|
|
.SetProjection(Projections.Property(nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid)));
|
|
|
|
var employee2SchedCrit = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), employeeListRelationCriteria);
|
|
|
|
c.Add(employee2SchedCrit);
|
|
|
|
var sql = Expression.Sql($"{nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM supportconcept2newschapp WHERE supportconceptoid = {pSupportConceptOid})");
|
|
|
|
c.Add(sql);
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IList<InvoiceBase> GetInvoiceBasesBySupportConceptOids(List<long> pSupprortConceptOids)
|
|
{
|
|
var c = CreateCriteria<InvoiceBase>();
|
|
|
|
c.Add(Restrictions.In(nameof(InvoiceBase.SupportConceptOid), pSupprortConceptOids));
|
|
|
|
return c.List<InvoiceBase>();
|
|
}
|
|
|
|
public IEnumerable<SettlementInvoice> GetSettlementInvoiceBySupportConceptOids(List<long> pSupportConceptOids)
|
|
{
|
|
return CreateCriteria<SettlementInvoice>()
|
|
.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.In("ib." + InvoiceBase.PropertyName_SupportConceptOid, pSupportConceptOids))
|
|
.List<SettlementInvoice>();
|
|
}
|
|
|
|
public IList<ServiceInvoice> GetServiceInvoicesByInvoiceBaseOids(List<long> pIinvoiceBaseOids)
|
|
{
|
|
var res = CreateCriteria<ServiceInvoice>()
|
|
.CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
|
|
.Add(Restrictions.In("ib." + BeWoEntityBase.PropertyName_Oid, pIinvoiceBaseOids))
|
|
.List<ServiceInvoice>();
|
|
|
|
return res;
|
|
}
|
|
|
|
public IList<AdditionalServiceBooking> GetAllAdditionalServiceBookingsForCustomer(long pCustomerOid)
|
|
{
|
|
return CreateCriteria<AdditionalServiceBooking>()
|
|
.CreateAlias(AdditionalServiceBooking.PropertyName_Customer2AddServiceBookings, "c2s", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("c2s.CustomerOid", pCustomerOid))
|
|
.List<AdditionalServiceBooking>();
|
|
}
|
|
|
|
public IList<AdditionalServiceGroupOfPeople> GetAdditionalServiceGroupOfPeopleForCustomer(long pCustomerOid)
|
|
{
|
|
var c = CreateCriteria<AdditionalServiceGroupOfPeople>();
|
|
|
|
c.CreateCriteria(nameof(AdditionalServiceGroupOfPeople.CustomerList), JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), pCustomerOid));
|
|
|
|
return c.List<AdditionalServiceGroupOfPeople>();
|
|
}
|
|
|
|
public IList<SchedulerAppointment> GetTasksAndAppointmentsBySupportConceptOids(List<long> pSupportConceptOids)
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>();
|
|
|
|
var list = "";
|
|
for(var i = 0; i < pSupportConceptOids.Count; i++)
|
|
{
|
|
if(i != pSupportConceptOids.Count - 1)
|
|
{
|
|
list += "" + pSupportConceptOids[i] + ",";
|
|
}
|
|
else
|
|
{
|
|
list += "" + pSupportConceptOids[i];
|
|
}
|
|
}
|
|
|
|
var blah = $"{nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM supportconcept2newschapp WHERE supportconceptoid IN ({list}))";
|
|
var supportConceptCriterion = Expression.Sql(blah);
|
|
|
|
c.Add(supportConceptCriterion);
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public IList<Customer2Token> GetCustomer2TokensByCustomerOid(long pCustomerOid)
|
|
{
|
|
var c = CreateCriteria<Customer2Token>();
|
|
|
|
c.Add(Restrictions.Eq(nameof(Customer2Token.Customer) + "." + nameof(BeWoEntityBase.Oid), pCustomerOid));
|
|
|
|
return c.List<Customer2Token>();
|
|
}
|
|
|
|
public IList<Employee2Token> GeEmployee2TokensByEmployeeOid(long employeeOid)
|
|
{
|
|
var c = CreateCriteria<Employee2Token>();
|
|
|
|
c.Add(Restrictions.Eq(nameof(Employee2Token.Employee) + "." + nameof(BeWoEntityBase.Oid), employeeOid));
|
|
|
|
return c.List<Employee2Token>();
|
|
}
|
|
|
|
public IList<SchedulerAppointment> GetTestAppointments()
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>();
|
|
|
|
c.Add(Restrictions.Eq(nameof(BeWoEntityBase.Notice), BS.Shared.Core.Utils.TestAppointmentNotice));
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public bool CheckForOverlappingSubstitutions(long? employeeOid, long? customerOid, DateTime startDate, DateTime endDate, long? substitutionOid)
|
|
{
|
|
var c = CreateCriteria<Vertretung>();
|
|
|
|
var employeeRestriction = Restrictions.Eq(nameof(Vertretung.EmployeeOid), employeeOid);
|
|
var customerRestriction = Restrictions.Eq(nameof(Vertretung.CustomerOid), customerOid);
|
|
|
|
var notCurrentSubstitution = Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), substitutionOid));
|
|
|
|
var peopleRestriction = Restrictions.Or(employeeRestriction, customerRestriction);
|
|
var timeRestriction = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(Vertretung.VertretungsZeitraumVon), nameof(Vertretung.VertretungsZeitraumBis));
|
|
|
|
c.Add(peopleRestriction).Add(timeRestriction).Add(notCurrentSubstitution);
|
|
|
|
return c.List<Vertretung>().Any();
|
|
}
|
|
|
|
private static AbstractCriterion CreateBetweenDateTimesCriterion(DateTime start, DateTime end, string propertyNameStart, string propertyNameEnd)
|
|
{
|
|
/* -- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET --
|
|
* Sql für Spalten namens 'StartDate' und 'EndDate':
|
|
* WHERE
|
|
* ((start >= StartDate AND end <= StartDate) OR (start <= StartDate AND end >= EndDate))
|
|
* OR
|
|
* ((start <= StartDate AND start >= EndDate) OR (start >= StartDate AND end <= EndDate))
|
|
*/
|
|
|
|
//var inBetween1 = Restrictions.And(Restrictions.Ge(propertyNameStart, start), Restrictions.Le(propertyNameStart, end));
|
|
//var inBetween2 = Restrictions.And(Restrictions.Le(propertyNameStart, start), Restrictions.Ge(propertyNameEnd, end));
|
|
//var inBetween3 = Restrictions.And(Restrictions.Le(propertyNameStart, start), Restrictions.Ge(propertyNameEnd, start));
|
|
//var inBetween4 = Restrictions.And(Restrictions.Ge(propertyNameStart, start), Restrictions.Le(propertyNameEnd, end));
|
|
|
|
//return Restrictions.Or(Restrictions.Or(inBetween1, inBetween2), Restrictions.Or(inBetween3, inBetween4));
|
|
// -- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET --
|
|
|
|
// NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU
|
|
/* Sql für Spalten namens 'StartDate' und 'EndDate':
|
|
* (StartDate < '2020-11-19 10:00:00' AND EndDate <= '2020-11-19 12:00:00' AND EndDate > '2020-11-19 10:00:00')
|
|
OR
|
|
(StartDate < '2020-11-19 10:00:00' AND EndDate > '2020-11-19 12:00:00')
|
|
OR
|
|
(StartDate > '2020-11-19 10:00:00' AND StartDate < '2020-11-19 12:00:00')
|
|
OR
|
|
(StartDate = '2020-11-19 10:00:00' AND EndDate = '2020-11-19 12:00:00')
|
|
OR
|
|
(StartDate = '2020-11-19 10:00:00' AND EndDate >= '2020-11-19 12:00:00')
|
|
*/
|
|
// NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU
|
|
|
|
var inBetween1 = Restrictions.And(Restrictions.Lt(propertyNameStart, start), Restrictions.And(Restrictions.Le(propertyNameEnd, end), Restrictions.Gt(propertyNameEnd, start)));
|
|
var inBetween2 = Restrictions.And(Restrictions.Lt(propertyNameStart, start), Restrictions.Gt(propertyNameEnd, end));
|
|
var inBetween3 = Restrictions.And(Restrictions.Gt(propertyNameStart, start), Restrictions.Lt(propertyNameStart, end));
|
|
var inBetween4 = Restrictions.And(Restrictions.Eq(propertyNameStart, start), Restrictions.Eq(propertyNameEnd, end));
|
|
var inBetween5 = Restrictions.And(Restrictions.Eq(propertyNameStart, start), Restrictions.Le(propertyNameEnd, end));
|
|
|
|
return Restrictions.Or(inBetween1, Restrictions.Or(Restrictions.Or(inBetween2, inBetween3), Restrictions.Or(inBetween4, inBetween5)));
|
|
}
|
|
|
|
public bool CheckForOverlappingAbsenceTimes(DateTime startDate, DateTime endDate, long? employeeOid, long? customerOid)
|
|
{
|
|
var c = CreateCriteria<AbsenceTime>();
|
|
|
|
var peopleRestriction = employeeOid != null ? Restrictions.Eq(nameof(AbsenceTime.EmployeeOid), employeeOid) : Restrictions.Eq(nameof(AbsenceTime.CustomerOid), customerOid);
|
|
|
|
var timeRestriction = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(AbsenceTime.Start), nameof(AbsenceTime.End));
|
|
|
|
c.Add(peopleRestriction).Add(timeRestriction);
|
|
|
|
return c.List<AbsenceTime>().Any();
|
|
}
|
|
|
|
public IList<Vertretung> GetLastSubstitutionItems(long employeeOid, int count)
|
|
{
|
|
var criteria = CreateCriteria<Vertretung>();
|
|
|
|
criteria.Add(Restrictions.Eq(nameof(Vertretung.EmployeeOid), employeeOid));
|
|
|
|
criteria.AddOrder(Order.Desc(nameof(Vertretung.VertretungsZeitraumBis)));
|
|
|
|
criteria.SetMaxResults(count);
|
|
|
|
return criteria.List<Vertretung>().Where(w => w.VertretungsZeitraumVon > DateTime.MinValue && w.VertretungsZeitraumBis > DateTime.MinValue).ToList();
|
|
}
|
|
|
|
public Dictionary<Customer, List<ArbeitszeitEintrag>> GetAssistanceTimesForEmployee(long employeeOid, DateTime start, DateTime end)
|
|
{
|
|
// Arbeitszeit -> keine EmployeeOid, nur in den Arbeitszeiteinträgen
|
|
|
|
var criteria = CreateCriteria<Arbeitszeit>();
|
|
|
|
var detachedCriteria = DetachedCriteria.For<ArbeitszeitEintrag>().Add(Restrictions.Eq(nameof(ArbeitszeitEintrag.Employee) + ".Oid", employeeOid)).SetProjection(Projections.Property(nameof(ArbeitszeitEintrag.ArbeitszeitOid)));
|
|
|
|
var subquery = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), detachedCriteria);
|
|
|
|
criteria.Add(subquery);
|
|
|
|
criteria.Add(CreateArbeitszeitenTimeRestictions(start, end));
|
|
|
|
var assistanceTimes = criteria.List<Arbeitszeit>();
|
|
|
|
var result = new Dictionary<Customer, List<ArbeitszeitEintrag>>();
|
|
|
|
foreach(var assistanceTimeEntry in assistanceTimes)
|
|
{
|
|
if(assistanceTimeEntry.Customer != null)
|
|
{
|
|
result.AddOrUpdateValueInDictionary(assistanceTimeEntry.Customer, assistanceTimeEntry.ArbeitszeitEintraege.ToList());
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private ICriterion CreateArbeitszeitenTimeRestictions(DateTime start, DateTime end)
|
|
{
|
|
// GueltigVon und GueltigBis sind null
|
|
var gueltigVonAndGueltigBisAreNull = Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.IsNull(nameof(Arbeitszeit.GueltigBis)));
|
|
|
|
// GueltigVon ist null, GueltigBis ist nicht null
|
|
var gueltigVonIsNullAndGueltigBisIsGtStart = Restrictions.And(Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.Gt(nameof(Arbeitszeit.GueltigBis), start)), Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.Ge(nameof(Arbeitszeit.GueltigBis), start)));
|
|
|
|
// GueltigVon ist nicht null, GueltigBis ist null
|
|
var gueltigBisIsNullAndGueltigVonIsLtEnd = Restrictions.And(Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigBis)), Restrictions.Gt(nameof(Arbeitszeit.GueltigVon), end)));
|
|
|
|
var and1 = Restrictions.And(Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigBis)));
|
|
var and3 = Restrictions.And(Restrictions.Le(nameof(Arbeitszeit.GueltigVon), start), Restrictions.Ge(nameof(Arbeitszeit.GueltigBis), start));
|
|
var and4 = Restrictions.And(Restrictions.Le(nameof(Arbeitszeit.GueltigVon), end), Restrictions.Gt(nameof(Arbeitszeit.GueltigBis), end));
|
|
var and5 = Restrictions.And(Restrictions.Ge(nameof(Arbeitszeit.GueltigVon), start), Restrictions.Le(nameof(Arbeitszeit.GueltigBis), end));
|
|
|
|
var or1 = Restrictions.Or(and4, and5);
|
|
var or2 = Restrictions.Or(and3, or1);
|
|
|
|
// GueltigVon und GueltigBis sind nicht null
|
|
var gueltigVonAndGueltigBisAreNotNull = Restrictions.And(and1, or2);
|
|
|
|
return Restrictions.Or(gueltigVonAndGueltigBisAreNull, Restrictions.Or(Restrictions.Or(gueltigVonIsNullAndGueltigBisIsGtStart, gueltigBisIsNullAndGueltigVonIsLtEnd), gueltigVonAndGueltigBisAreNotNull));
|
|
}
|
|
|
|
public IList<Customer> GetCustomersWithSubstitutionNeedUnset()
|
|
{
|
|
var c = CreateCriteria<Customer>();
|
|
|
|
c.Add(Restrictions.IsNull(nameof(Customer.SubstitutionNeed)));
|
|
|
|
return c.List<Customer>();
|
|
}
|
|
|
|
public List<long> FindTeamRelatedCustomerOids(long employeeOid)
|
|
{
|
|
var result = new List<long>();
|
|
|
|
var teams = CreateCriteriaIsActive<Team>()
|
|
.Add(Restrictions.IsNotNull(nameof(BeWoEntityBase.Oid)))
|
|
.CreateCriteria(nameof(Team.MemberList), JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
|
|
.List<Team>();
|
|
|
|
var members = new List<Employee>();
|
|
|
|
foreach(var team in teams)
|
|
{
|
|
members.AddRangeIfElementsNotIn(team.MemberList);
|
|
}
|
|
|
|
foreach(var member in members)
|
|
{
|
|
foreach(var employee2customer in member.Employee2CustomerList)
|
|
{
|
|
if(employee2customer.CustomerOid.HasValue)
|
|
{
|
|
result.AddIfNotIn(employee2customer.CustomerOid.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<Customer> FindCustomersForAbsenceTimesByStartAndEnd(DateTime intervalStart, DateTime intervalEnd)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<Customer>();
|
|
// Arbeitszeiten im gewählten Intervall holen und dann die einträge nach customeroid durchsuchen
|
|
// TODO: implementieren
|
|
|
|
return criteria.List<Customer>().ToList();
|
|
}
|
|
|
|
public List<CostBearer2SupportConcept> FindCostBearer2SupportConceptsByOids(List<long> costbearer2SupportConceptOids)
|
|
{
|
|
var c = CreateCriteriaIsActive<CostBearer2SupportConcept>();
|
|
|
|
c.Add(Restrictions.In(nameof(CostBearer2SupportConcept.Oid), costbearer2SupportConceptOids));
|
|
|
|
return c.List<CostBearer2SupportConcept>().ToList();
|
|
}
|
|
|
|
public bool IsResourceAvailable(DateTime start, DateTime end, long resourceOid)
|
|
{
|
|
var c = CreateCriteriaIsActive<Resource>();
|
|
|
|
var sql = $"SELECT COUNT(*) FROM resource WHERE oid = {resourceOid} AND isactive = 1 AND oid NOT IN (SELECT resourceoid FROM resource2newschapp r WHERE r.newschappoid NOT IN (SELECT oid FROM newschedulerappointment WHERE startdate > '{start:yyyy-MM-dd HH:mm:ss}' OR enddate < '{end:yyyy-MM-dd HH:mm:ss}'));";
|
|
|
|
var criterion = Expression.Sql(sql);
|
|
|
|
c.Add(criterion);
|
|
|
|
return c.List().Count > 0;
|
|
}
|
|
|
|
public List<Resource> GetAvailableResources(DateTime start, DateTime end)
|
|
{
|
|
var c = CreateCriteria<Resource>("r").Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active));
|
|
|
|
var sql = $"Oid NOT IN (SELECT Oid FROM resource WHERE isactive = 1 AND Oid NOT IN (SELECT resourceoid FROM resource2newschapp r2n WHERE r2n.newschappoid NOT IN (SELECT oid FROM newschedulerappointment WHERE startdate > '{start:yyyy-MM-dd HH:mm:ss}' OR enddate < '{end:yyyy-MM-dd HH:mm:ss}')))";
|
|
|
|
var criterion = Expression.Sql(sql);
|
|
|
|
c.Add(criterion);
|
|
|
|
return c.List<Resource>().ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft anhand der Oids von Ressourcen deren Verfügbarkeit in einem Zeitraum.
|
|
/// Gibt die nicht verfügbaren Ressourcen zurück für eine detaillierte Fehlermeldung.
|
|
/// </summary>
|
|
/// <param name="resourceOids">Die Oids der zu überprüfenden Ressourcen</param>
|
|
/// <param name="start">Anfang des zu prüfenden Intervalls</param>
|
|
/// <param name="end">Ende des zu prüfenden Intervalls</param>
|
|
/// <param name="selectedAppointmentOid">Die Oid des Termins</param>
|
|
/// <param name="recurrenceId">Recurrence Id, falls es sich um einen Serientermin handelt, der keine eigene Oid hat.</param>
|
|
/// <param name="occurrenceIndex">Occurrence-Index des Serientermins ohne eigene Oid</param>
|
|
/// <returns>Die im angegebenen Zeitraum belegten Ressourcen</returns>
|
|
public List<Resource> CheckAvailabilityOfResources(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid, Guid? recurrenceId = null, int? occurrenceIndex = null)
|
|
{
|
|
var c = CreateCriteria<Resource>("r").Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active)).Add(Restrictions.In(nameof(BeWoEntityBase.Oid), resourceOids));
|
|
|
|
var excludingSelectedAppointment = selectedAppointmentOid.HasValue ? $"Oid <> {selectedAppointmentOid} AND " : "";
|
|
|
|
var sql = "Oid IN " +
|
|
"(SELECT ResourceOid FROM resource2newschapp r2n WHERE r2n.NewSchAppOid IN " +
|
|
$"(SELECT Oid FROM newschedulerappointment WHERE IsActive = 1 AND Type <> 4 AND {excludingSelectedAppointment}('{start:yyyy-MM-dd HH:mm:ss}' > StartDate OR '{end:yyyy-MM-dd HH:mm:ss}' > StartDate) AND ('{start:yyyy-MM-dd HH:mm:ss}' < EndDate OR '{end:yyyy-MM-dd HH:mm:ss}' < EndDate)))";
|
|
|
|
var criterion = Expression.Sql(sql);
|
|
|
|
c.Add(criterion);
|
|
|
|
var resources = c.List<Resource>().ToList();
|
|
|
|
var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));
|
|
|
|
var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().ToList();
|
|
|
|
recurringAppointments = recurringAppointments.Where(s => s.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
|
|
|
|
if(recurringAppointments.Count == 0)
|
|
{
|
|
return resources;
|
|
}
|
|
|
|
var changedOccurrencesCriteria = CreateCriteriaIsActive<SchedulerAppointment>().Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 3));
|
|
var deletedOccurrencesCriteria = CreateCriteria<SchedulerAppointment>().Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 4));
|
|
|
|
var inBetween = CreateBetweenDateTimesCriterion(start, end, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));
|
|
|
|
changedOccurrencesCriteria.Add(inBetween);
|
|
deletedOccurrencesCriteria.Add(inBetween);
|
|
|
|
var appointments = new List<SchedulerAppointment>();
|
|
|
|
if(selectedAppointmentOid.HasValue)
|
|
{
|
|
changedOccurrencesCriteria.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid.Value)));
|
|
deletedOccurrencesCriteria.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid.Value)));
|
|
}
|
|
|
|
var changedOccurrences = new List<SchedulerAppointment>();
|
|
|
|
var recurrenceIds = string.Empty;
|
|
recurringAppointments.DoForEach(appointment => recurrenceIds += $"'{appointment.GetRecurrenceId()}',");
|
|
recurrenceIds = recurrenceIds.Trim(',');
|
|
|
|
if(recurrenceIds.Any())
|
|
{
|
|
var changedCriteria = CreateCriteriaIsActive<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 3))
|
|
.Add(Expression.Sql($"RecurrenceInfo IS NOT NULL AND RecurrenceInfo LIKE '%Id%' AND SUBSTRING(RecurrenceInfo, LOCATE('Id', RecurrenceInfo) + 4, 36) IN ({recurrenceIds})"));
|
|
|
|
changedOccurrences = changedCriteria.List<SchedulerAppointment>().ToList();
|
|
}
|
|
|
|
//var changedOccurrences = changedOccurrencesCriteria.List<SchedulerAppointment>().Where(a => a.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
|
|
var deletedOccurrences = deletedOccurrencesCriteria.List<SchedulerAppointment>().Where(a => a.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
|
|
|
|
// Sich wiederholende Termine erzeugen und dabei die Ausnahmen und gelöschten Ausnahmen ignorieren
|
|
var interval = new TimeInterval(start, end);
|
|
foreach(var recurringAppointment in recurringAppointments)
|
|
{
|
|
var recurrenceInfo = new RecurrenceInfo();
|
|
recurrenceInfo.FromXml(recurringAppointment.RecurrenceInfo);
|
|
|
|
var occurenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);
|
|
|
|
// Das Muster für die Terminserie wird berechnet
|
|
var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);
|
|
pattern.RecurrenceInfo.FromXml(recurringAppointment.RecurrenceInfo);
|
|
pattern.Start = pattern.RecurrenceInfo.Start;
|
|
pattern.End = pattern.RecurrenceInfo.End;
|
|
|
|
if(!Guid.TryParse(pattern.RecurrenceInfo.Id.ToString(), out var patternId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Die Serientermine werden berechnet (ausnahmslos, d.h. es werden auch bearbeitete und gelöschte Termine erstellt, die herausgefiltert werden müssen).
|
|
var occurrences = occurenceCalculator.CalcOccurrences(interval, pattern);
|
|
|
|
var occurrenceAppointments = occurrences.GetAppointments(interval);
|
|
|
|
foreach(var occurrence in occurrenceAppointments)
|
|
{
|
|
if(recurringAppointment.EndDate is null || recurringAppointment.StartDate is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Sicher machen
|
|
var index = occurrence.RecurrenceIndex;
|
|
|
|
var isDeletedOrChanged = changedOccurrences.Any(a =>
|
|
{
|
|
var guid = a.GetRecurrenceIdAndIndex(out var i);
|
|
|
|
if(guid is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(guid.Value.Equals(patternId) && index == i)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}) || deletedOccurrences.Any(a =>
|
|
{
|
|
var guid = a.GetRecurrenceIdAndIndex(out var i);
|
|
|
|
if(guid is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(guid.Value.Equals(patternId) && index == i)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
|
|
if(isDeletedOrChanged)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var duration = (recurringAppointment.EndDate.Value - recurringAppointment.StartDate.Value).TotalMinutes;
|
|
var isInIntervalTest = start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration));
|
|
|
|
if(!isInIntervalTest)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var occurrenceAppointment = new SchedulerAppointment
|
|
{
|
|
AllDay = occurrence.AllDay,
|
|
CustomerList = recurringAppointment.CustomerList,
|
|
Notice = recurringAppointment.Notice,
|
|
EmployeeList = recurringAppointment.EmployeeList,
|
|
EndDate = occurrence.Start.AddMinutes(duration),
|
|
FormerBookingSequenceOid = recurringAppointment.FormerBookingSequenceOid,
|
|
IsPrivate = recurringAppointment.IsPrivate,
|
|
Location = recurringAppointment.Location,
|
|
Originator = recurringAppointment.Originator,
|
|
RecurrenceInfo = occurrence.RecurrenceInfo.ToXml(),
|
|
ReminderInfo = recurringAppointment.ReminderInfo,
|
|
ResourceList = recurringAppointment.ResourceList,
|
|
StartDate = occurrence.Start,
|
|
Subject = recurringAppointment.Subject ?? Empty,
|
|
Type = recurringAppointment.Type
|
|
};
|
|
|
|
if(!(recurrenceId is null) && occurrenceIndex.HasValue)
|
|
{
|
|
var recId = occurrenceAppointment.GetRecurrenceId();
|
|
|
|
if((recId?.Equals(recurrenceId.Value) ?? false) && index.Equals(occurrenceIndex.Value))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
appointments.AddIfNotIn(occurrenceAppointment);
|
|
}
|
|
}
|
|
|
|
appointments.DoForEach(a => a.ResourceList.DoForEach(resources.AddIfNotIn));
|
|
|
|
return resources;
|
|
}
|
|
|
|
public IList<ServiceRecord> FindCustomerServiceRecordsForKilometerauswertung(long customerOid, DateTimeSpan pSpan)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
|
|
.Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0m));
|
|
|
|
var orCriteria = Restrictions.Or(
|
|
Restrictions.Between(nameof(ServiceRecord.Start), pSpan.StartDateTime, pSpan.EndDateTime),
|
|
Restrictions.Between(nameof(ServiceRecord.End), pSpan.StartDateTime, pSpan.EndDateTime));
|
|
|
|
orCriteria = Restrictions.Or(orCriteria,
|
|
Restrictions.And(
|
|
Restrictions.Le(nameof(ServiceRecord.Start), pSpan.EndDateTime),
|
|
Restrictions.Ge(nameof(ServiceRecord.End), pSpan.StartDateTime)));
|
|
|
|
lCriteria.Add(orCriteria);
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public Dictionary<long, List<ServiceRecord>> FindListOfCustomerServiceRecordsForKilometerauswertung(List<long> customerOids, List<long> serviceDescriptionOids, DateTimeSpan span)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.CustomerOid), customerOids))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
|
|
.Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0m));
|
|
|
|
var orCriteria = Restrictions.Or(
|
|
Restrictions.Between(nameof(ServiceRecord.Start), span.StartDateTime, span.EndDateTime),
|
|
Restrictions.Between(nameof(ServiceRecord.End), span.StartDateTime, span.EndDateTime));
|
|
|
|
orCriteria = Restrictions.Or(orCriteria,
|
|
Restrictions.And(
|
|
Restrictions.Le(nameof(ServiceRecord.Start), span.EndDateTime),
|
|
Restrictions.Ge(nameof(ServiceRecord.End), span.StartDateTime)));
|
|
|
|
lCriteria.Add(orCriteria);
|
|
|
|
var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
var result = new Dictionary<long, List<ServiceRecord>>();
|
|
|
|
foreach(var serviceRecord in allServiceRecords)
|
|
{
|
|
if(serviceDescriptionOids == null || serviceDescriptionOids.Count == 0 || serviceDescriptionOids.Contains(serviceRecord.ServiceDescription.Oid.Value))
|
|
{
|
|
result.AddOrUpdateValueInDictionary(serviceRecord.CustomerOid.Value, new List<ServiceRecord> { serviceRecord });
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public bool CheckForAnyServiceRecordsWithDistanceValues(List<long> customerOids, DateTimeSpan span)
|
|
{
|
|
return FindListOfCustomerServiceRecordsForKilometerauswertung(customerOids, null, span).Any();
|
|
}
|
|
|
|
public List<Customer> GetAllCustomersForEmployee(long? employeeOid)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current.User;
|
|
}
|
|
else
|
|
{
|
|
user = SessionFacade.LoggedInUser;
|
|
}
|
|
}
|
|
|
|
var rights = new List<UserRightType>();
|
|
|
|
user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));
|
|
|
|
var lCriteria = CreateCriteriaIsActive<Customer>();
|
|
|
|
if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.CustomerView_View))
|
|
{
|
|
return lCriteria.List<Customer>().ToList();
|
|
}
|
|
|
|
var result = new List<Customer>();
|
|
|
|
if(rights.Contains(UserRightType.Customer_ViewMyCustomers))
|
|
{
|
|
result = user.Employee.Employee2CustomerList.Select(employee2Customer => employee2Customer.Customer).Distinct().ToList();
|
|
}
|
|
|
|
if(rights.Contains(UserRightType.Customer_ViewMyTeams))
|
|
{
|
|
var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);
|
|
|
|
result.AddRangeIfElementsNotIn(FindCustomersOfTeams(teams.Select(team => team.Oid.Value)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// TODO 16.02.2021: Alias für EmployeeOid erstellen?
|
|
public IList<ConfirmationReceiptSignature> GetConfirmationReceiptSignaturesByEmployee(long employeeOid, DateTimeSpan timeSpan)
|
|
{
|
|
var liste = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
|
|
//.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "s", JoinType.InnerJoin)
|
|
.Add(CreateBetweenDateTimesCriterion(timeSpan.StartDateTime, timeSpan.EndDateTime, "s.Start", "s.End")).List<ConfirmationReceiptSignature>();
|
|
|
|
return liste;
|
|
}
|
|
|
|
public List<ConfirmationReceiptSignature> GetConfirmationReceiptSignaturesByServiceRecord(long serviceRecordOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.Eq("serviceRecord.Oid", serviceRecordOid));
|
|
|
|
return criteria.List<ConfirmationReceiptSignature>().ToList();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindEmployeeServiceRecordsForKilometerauswertung(long employeeOid, DateTimeSpan timeSpan)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.EmployeeOid), employeeOid))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
|
|
.Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0m));
|
|
|
|
var orCriteria = Restrictions.Or(
|
|
Restrictions.Between(nameof(ServiceRecord.Start), timeSpan.StartDateTime, timeSpan.EndDateTime),
|
|
Restrictions.Between(nameof(ServiceRecord.End), timeSpan.StartDateTime, timeSpan.EndDateTime));
|
|
|
|
orCriteria = Restrictions.Or(orCriteria,
|
|
Restrictions.And(
|
|
Restrictions.Le(nameof(ServiceRecord.Start), timeSpan.EndDateTime),
|
|
Restrictions.Ge(nameof(ServiceRecord.End), timeSpan.StartDateTime)));
|
|
|
|
lCriteria.Add(orCriteria);
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public Dictionary<long, List<ServiceRecord>> FindListOfEmployeeServiceRecordsForKilometerauswertung(List<long> employeeOids, List<long> serviceDescriptionOids, DateTimeSpan span)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
|
|
.Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0m));
|
|
|
|
var orCriteria = Restrictions.Or(
|
|
Restrictions.Between(nameof(ServiceRecord.Start), span.StartDateTime, span.EndDateTime),
|
|
Restrictions.Between(nameof(ServiceRecord.End), span.StartDateTime, span.EndDateTime));
|
|
|
|
orCriteria = Restrictions.Or(orCriteria,
|
|
Restrictions.And(
|
|
Restrictions.Le(nameof(ServiceRecord.Start), span.EndDateTime),
|
|
Restrictions.Ge(nameof(ServiceRecord.End), span.StartDateTime)));
|
|
|
|
lCriteria.Add(orCriteria);
|
|
|
|
var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
var result = new Dictionary<long, List<ServiceRecord>>();
|
|
|
|
foreach(var serviceRecord in allServiceRecords)
|
|
{
|
|
if(serviceDescriptionOids == null || serviceDescriptionOids.Count == 0 || serviceDescriptionOids.Contains(serviceRecord.ServiceDescription.Oid.Value))
|
|
{
|
|
result.AddOrUpdateValueInDictionary(serviceRecord.EmployeeOid.Value, new List<ServiceRecord> { serviceRecord });
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<Employee> GetAllActiveEmployeesForEmployee(long? employeeOid)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current.User;
|
|
}
|
|
else
|
|
{
|
|
user = SessionFacade.LoggedInUser;
|
|
}
|
|
}
|
|
|
|
if(user.Employee.Oid == null)
|
|
{
|
|
return new List<Employee>();
|
|
}
|
|
|
|
var rights = new List<UserRightType>();
|
|
|
|
user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));
|
|
|
|
var lCriteria = CreateCriteriaIsActive<Employee>();
|
|
|
|
if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.EmployeeView_View))
|
|
{
|
|
return lCriteria.List<Employee>().ToList();
|
|
}
|
|
|
|
var result = new List<Employee>();
|
|
|
|
if(rights.Contains(UserRightType.Employee_AllowViewOwnEmployees))
|
|
{
|
|
result.AddIfNotIn(user.Employee);
|
|
}
|
|
|
|
if(rights.Contains(UserRightType.Employee_AllowViewOwnTeam))
|
|
{
|
|
var leadingTeams = user.Employee.LeadingTeams;
|
|
leadingTeams.DoForEach(team =>
|
|
{
|
|
result.AddIfNotIn(team.Leader);
|
|
|
|
result.AddRangeIfElementsNotIn(team.MemberList);
|
|
});
|
|
|
|
var teams = FindTeamsOfEmployee(user.Employee.Oid.Value);
|
|
teams.DoForEach(team =>
|
|
{
|
|
result.AddIfNotIn(team.Leader);
|
|
|
|
result.AddRangeIfElementsNotIn(team.MemberList);
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<Quittierungsbelegsstatus> GetAllQuittierungsbelegStatusForMonth(DateTime start, DateTime ende)
|
|
{
|
|
DateTime begin = new DateTime(start.Year, start.Month, start.Day);
|
|
DateTime end = new DateTime(ende.Year, ende.Month, ende.Day);
|
|
|
|
var crit = CreateCriteria<Quittierungsbelegsstatus>();
|
|
crit.Add(Restrictions.Ge("Startdatum", begin));
|
|
crit.Add(Restrictions.Le("Enddatum", end));
|
|
return crit.List<Quittierungsbelegsstatus>();
|
|
}
|
|
|
|
public IList<Vorlagentabelle> GetAllActiveVorlagentabellen()
|
|
{
|
|
var crit = CreateCriteria<Vorlagentabelle>();
|
|
crit.Add(Restrictions.Gt("IsActive", 0));
|
|
return crit.List<Vorlagentabelle>();
|
|
}
|
|
|
|
public IList<Dokumentvorlage> GetAllDokumentvorlagenInFolder(long folderOid)
|
|
{
|
|
var crit = CreateCriteria<Dokumentvorlage>();
|
|
crit.Add(Restrictions.Eq("Parent", folderOid));
|
|
|
|
return crit.List<Dokumentvorlage>();
|
|
}
|
|
|
|
// TODO 16.02.2021: Alias für EmployeeOid erstellen?
|
|
public bool HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
|
|
//.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));
|
|
|
|
var hasSignatures = criteria.List<ConfirmationReceiptSignature>().Any();
|
|
|
|
return hasSignatures;
|
|
}
|
|
|
|
public bool HasConfirmationReceiptSignatureByDateAndCustomer(long customerOid, DateTimeSpan timeSpan, SignatureType signatureType)
|
|
{
|
|
var start = timeSpan.StartDate;
|
|
var end = timeSpan.EndDate;
|
|
|
|
var timeSpanCriterion = CreateBetweenDateTimesCriterion(start, end, $"serviceRecord.{nameof(ServiceRecord.Start)}", $"serviceRecord.{nameof(ServiceRecord.End)}");
|
|
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.Eq($"serviceRecord.{nameof(ServiceRecord.CustomerOid)}", customerOid))
|
|
.Add(timeSpanCriterion);
|
|
|
|
return criteria.List<ConfirmationReceiptSignature>().Any();
|
|
}
|
|
|
|
public bool HasConfirmationReceiptSignatureByDateAndEmployeeAndCustomer(long customerOid, long employeeOid, DateTime serviceRecordStart, DateTime serviceRecordEnd, out List<ConfirmationReceiptSignature> monatsunterschriften)
|
|
{
|
|
var timePartOfQuery = " STR_TO_DATE(CONCAT(SUBSTRING(TimeSpanString, 18, 4), '-', SUBSTRING(TimeSpanString, 4, 2), '-', SUBSTRING(TimeSpanString, 1, 2)), '%Y-%m-%d') AND STR_TO_DATE(CONCAT(SUBSTRING(TimeSpanString, 18, 4), '-', SUBSTRING(TimeSpanString, 15, 2), '-', SUBSTRING(TimeSpanString, 12, 2)), '%Y-%m-%d') ";
|
|
|
|
var sql =
|
|
"SELECT * FROM confirmationreceiptsignature " +
|
|
$"WHERE ('{serviceRecordStart:yyyy-MM-dd HH:mm:ss}' BETWEEN {timePartOfQuery} OR '{serviceRecordEnd:yyyy-MM-dd HH:mm:ss}' BETWEEN {timePartOfQuery}) " +
|
|
$"AND (CustomerOid = {customerOid} OR EmployeeOid = {employeeOid})";
|
|
|
|
var query = Session.CreateSQLQuery(sql);
|
|
|
|
query.AddEntity("crs", typeof(ConfirmationReceiptSignature));
|
|
|
|
var signatures = query.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
monatsunterschriften = signatures;
|
|
|
|
return signatures.Any();
|
|
}
|
|
|
|
public IList<Team> GetAllActiveTeamsForEmployee(long? employeeOid)
|
|
{
|
|
ApplicationUser user;
|
|
var result = new List<Team>();
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current.User;
|
|
}
|
|
else
|
|
{
|
|
user = SessionFacade.LoggedInUser;
|
|
}
|
|
}
|
|
|
|
if(user.Employee.Oid == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rights = new List<UserRightType>();
|
|
|
|
user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));
|
|
|
|
if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.TeamView_ViewAll))
|
|
{
|
|
return CreateCriteriaIsActive<Team>().List<Team>();
|
|
}
|
|
|
|
if(rights.Contains(UserRightType.TeamView_ViewMyTeams))
|
|
{
|
|
result.AddRangeIfElementsNotIn(FindLeadingTeams(user.Employee.Oid.Value));
|
|
result.AddRangeIfElementsNotIn(FindTeamsOfEmployee(user.Employee.Oid.Value));
|
|
|
|
return result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// TODO 16.02.2021: Alias für EmployeeOid erstellen?
|
|
public IEnumerable<ConfirmationReceiptSignature> FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
|
|
//.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));
|
|
|
|
return criteria.List<ConfirmationReceiptSignature>();
|
|
}
|
|
|
|
//public SchedulerAppointment FindRootAppointmentByRecurrenceId(string recurrenceId)
|
|
//{
|
|
// if(Guid.TryParse(recurrenceId, out var guid))
|
|
// {
|
|
// var criteria = CreateCriteria<SchedulerAppointment>()
|
|
// .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere))
|
|
// .Add(Restrictions.Eq(nameof(Appointment.Type), 1));
|
|
|
|
// return criteria.List<SchedulerAppointment>().FirstOrDefault();
|
|
// }
|
|
|
|
// return null;
|
|
//}
|
|
|
|
public SchedulerAppointment FindIndexZeroChangedOccurrence(Guid? recurrenceId)
|
|
{
|
|
if(recurrenceId == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var kek = recurrenceId.ToString();
|
|
|
|
var str = $"<RecurrenceInfo Id=\"{kek}\" />";
|
|
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), str, MatchMode.Exact))
|
|
.Add(Restrictions.Not(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), "Index=\"", MatchMode.Anywhere)))
|
|
.Add(Restrictions.Eq(nameof(Appointment.Type), 3));
|
|
|
|
return criteria.List<SchedulerAppointment>().FirstOrDefault();
|
|
}
|
|
|
|
public string ValidateSchedulerAppointment(DateTime start, DateTime end, IEnumerable<long> employees, IEnumerable<long> customers, List<long> resources, long originator, long? appointmentOid, Guid? recurrenceId = null, int occurrenceIndex = 0, bool shouldSkipResourceAvailability = false)
|
|
{
|
|
var resourceList = resources;
|
|
if(shouldSkipResourceAvailability)
|
|
{
|
|
resourceList = null;
|
|
}
|
|
|
|
var isOverlapping = OverlappingAppointmentsExist(start, end, employees, customers, resourceList, originator, appointmentOid, recurrenceId?.ToString() ?? "", occurrenceIndex);
|
|
|
|
// Die Ressourcen werden auf Verfügbarkeit im ausgewählten Zeitraum geprüft
|
|
var info = shouldSkipResourceAvailability ? new Dictionary<string, List<string>>() : CheckResourceAvailabilityWithEmployeeInformation(start, end, resources, appointmentOid, recurrenceId, occurrenceIndex);
|
|
|
|
var stringBuilder = new StringBuilder();
|
|
|
|
foreach(var resourceName2Intervals in info)
|
|
{
|
|
stringBuilder.AppendLine($"Die Ressource \"{resourceName2Intervals.Key}\" ist im ausgewählten Zeitraum {start:dd.MM.yyyy HH:mm} bis {end:dd.MM.yyyy HH:mm} bereits gebucht:");
|
|
if(!resourceName2Intervals.Value.All(IsNullOrWhiteSpace))
|
|
{
|
|
stringBuilder.Append("\r\n\r\n");
|
|
}
|
|
|
|
foreach(var interval in resourceName2Intervals.Value)
|
|
{
|
|
stringBuilder.AppendLine($"{interval}");
|
|
}
|
|
}
|
|
|
|
if(isOverlapping)
|
|
{
|
|
if(info.Any())
|
|
{
|
|
stringBuilder.Append("\n\n");
|
|
}
|
|
|
|
stringBuilder.Append("Dieser Termin überschneidet sich mit einem anderen bereits existierenden Termin.");
|
|
}
|
|
|
|
if(info.Any() || isOverlapping)
|
|
{
|
|
stringBuilder.Append("\n\nMöchten Sie trotzdem speichern?");
|
|
}
|
|
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public virtual IList FindFileattachmentOids(string text)
|
|
{
|
|
var q = Session.CreateSQLQuery($"SELECT Oid, bewofolderoid, objectoid, objecttid, path FROM FileAttachment WHERE Path like '%{text}%'");
|
|
|
|
return q.List();
|
|
}
|
|
|
|
public List<SupportConcept> GetActiveSupportConceptsForEmployee(long? employeeOid, CustomerFilterEnum supportConceptFilter)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current.User;
|
|
}
|
|
else
|
|
{
|
|
user = SessionFacade.LoggedInUser;
|
|
}
|
|
}
|
|
|
|
var lCriteria = CreateCriteriaIsActive<SupportConcept>();
|
|
|
|
var teamCustomerOids = new List<long>();
|
|
|
|
var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);
|
|
|
|
teams.DoForEach(team =>
|
|
{
|
|
var customer = FindCustomerOfTeam(team.Oid.Value);
|
|
|
|
teamCustomerOids.AddRangeIfElementsNotIn(customer.Select(c => c.Oid.Value));
|
|
});
|
|
|
|
// Der ApplicationUser darf alles Sehen oder alle Hilfepläne
|
|
if(user.CheckForAtLeastOneRight(new List<UserRightType> { UserRightType.ViewAll, UserRightType.SupportConcept_ViewAllSupportConcepts }) && supportConceptFilter == CustomerFilterEnum.All)
|
|
{
|
|
return lCriteria.List<SupportConcept>().ToList();
|
|
}
|
|
|
|
var customerOids = user.Employee.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue && (!employee2Customer.StartDate.HasValue || employee2Customer.StartDate <= DateTime.Now.Date) && (!employee2Customer.EndDate.HasValue || employee2Customer.EndDate >= DateTime.Now.Date)).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList();
|
|
|
|
// Wählt man "Nur Klienten meiner Teams anzeigen", sollen nicht die Hilfepläne der eigenen Klienten angezeigt werden.
|
|
if(supportConceptFilter == CustomerFilterEnum.TeamCustomer)
|
|
{
|
|
customerOids.Clear();
|
|
}
|
|
|
|
// Der ApplicationUser darf die Hilfepläne seiner Teams sehen
|
|
if(user.CheckForRight(UserRightType.SupportConcept_ViewMyTeams) && (supportConceptFilter == CustomerFilterEnum.TeamCustomer || supportConceptFilter == CustomerFilterEnum.All))
|
|
{
|
|
foreach(var coid in customerOids)
|
|
{
|
|
if(!teamCustomerOids.Contains(coid))
|
|
{
|
|
teamCustomerOids.Add(coid);
|
|
}
|
|
}
|
|
|
|
return GetAllActiveSupportConceptsByCustomers(teamCustomerOids, true).ToList();
|
|
}
|
|
|
|
return GetAllActiveSupportConceptsByCustomers(customerOids, true).ToList();
|
|
}
|
|
|
|
public IEnumerable<SchedulerAppointment> GetAllMobileTestAppointments()
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.Notice), "mob-dev-app"));
|
|
|
|
return c.List<SchedulerAppointment>();
|
|
}
|
|
|
|
public bool HasConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
// Prüfen, ob alle ServiceRecords mit ein und derselben Unterschrift verknüpft sind.
|
|
// Eine Unterschrift kann mehrere ServiceRecords in der LinkListe haben, die nicht in der zu prüfenden Oid-Liste sind.
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
var signatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var result = false;
|
|
|
|
if(serviceRecordOids.Any() && signatures.Any())
|
|
{
|
|
var blubb = new List<long>();
|
|
signatures.DoForEach(s =>
|
|
{
|
|
s.ServiceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr.Oid.HasValue)
|
|
{
|
|
blubb.AddIfNotIn(sr.Oid.Value);
|
|
}
|
|
});
|
|
});
|
|
|
|
result = serviceRecordOids.ContainsSameItemsAs(blubb);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ToDo: An neue Rechte anpassen!
|
|
// Methode, die herausfindet, ob eine Liste mit ServiceRecordOids zu genau einer Mitarbeiterunterschrift gehört
|
|
public ConfirmationReceiptSignature GetConfirmationReceiptSignatureForServiceRecords(List<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.AddOrder(Order.Desc(nameof(ConfirmationReceiptSignature.Oid)))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
var signatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var relatedServiceRecordOids = new List<long>();
|
|
signatures.DoForEach(s => relatedServiceRecordOids.AddRangeIfElementsNotIn(s.ServiceRecords.Select(x => x.Oid.Value)));
|
|
|
|
var containsItems = relatedServiceRecordOids.ContainsItems(serviceRecordOids);
|
|
|
|
return containsItems ? signatures.FirstOrDefault() : null;
|
|
}
|
|
|
|
public List<ConfirmationReceiptSignature> LoadConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var result = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public bool HasConfirmationReceiptSignaturesByCustomerAndServiceRecords(long customerOid, IEnumerable<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Customer))
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.CustomerOid), customerOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));
|
|
|
|
var hasSignatures = criteria.List<ConfirmationReceiptSignature>().Any();
|
|
|
|
return hasSignatures;
|
|
}
|
|
|
|
public List<ConfirmationReceiptSignature> LoadConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var result = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<long> LoadServiceRecordOidsWithConfirmationReceiptSignatures(IList<long> serviceRecordOids)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var result = new List<long>();
|
|
|
|
confirmationReceiptSignatures.DoForEach(crs => crs.ServiceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr.Oid.HasValue)
|
|
{
|
|
result.AddIfNotIn(sr.Oid.Value);
|
|
}
|
|
}));
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<long> LoadServiceRecordOidsWithConfirmationReceiptSignatures(IList<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var result = new List<long>();
|
|
|
|
confirmationReceiptSignatures.DoForEach(crs => crs.ServiceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr.Oid.HasValue)
|
|
{
|
|
result.AddIfNotIn(sr.Oid.Value);
|
|
}
|
|
}));
|
|
|
|
return result;
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> GetServiceRecordsWithoutConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()))
|
|
.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var serviceRecords = new List<ServiceRecord>();
|
|
|
|
confirmationReceiptSignatures.DoForEach(crs => serviceRecords.AddRangeIfElementsNotIn(crs.ServiceRecords));
|
|
|
|
return serviceRecords;
|
|
}
|
|
|
|
public InvoiceBase FindMaxInvoiceNumber(string numberPrefix)
|
|
{
|
|
return CreateCriteriaIsActive<InvoiceBase>()
|
|
.Add(Restrictions.Like(InvoiceBase.PropertyName_InvoiceNumber, numberPrefix + "%"))
|
|
.List<InvoiceBase>().OrderByDescending(i => i.InvoiceNumber).FirstOrDefault();
|
|
|
|
}
|
|
|
|
public List<Customer> GetActiveCustomersForEmployee(long? employeeOid, CustomerFilterEnum customerFilter, bool ignoreViewAllRight = false)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current?.User != null ? LoggedInUserOperationContextExt.Current.User : SessionFacade.LoggedInUser;
|
|
}
|
|
|
|
var lCriteria = CreateCriteriaIsActive<Customer>();
|
|
|
|
// Der ApplicationUser darf alles sehen
|
|
var viewAllRights = new List<UserRightType> { UserRightType.CustomerView_View };
|
|
if(!ignoreViewAllRight)
|
|
{
|
|
viewAllRights.Add(UserRightType.ViewAll);
|
|
}
|
|
|
|
if(user.CheckForAtLeastOneRight(viewAllRights) && customerFilter == CustomerFilterEnum.All)
|
|
{
|
|
return lCriteria.List<Customer>().ToList();
|
|
}
|
|
|
|
var customerOids = user.Employee.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList();
|
|
|
|
// Der ApplicationUser darf die Klienten seiner Teams sehen
|
|
if(user.CheckForRight(UserRightType.Customer_ViewMyTeams) && (customerFilter == CustomerFilterEnum.TeamCustomer || customerFilter == CustomerFilterEnum.All) && (user.Employee?.Oid.HasValue ?? false))
|
|
{
|
|
var teamCustomerOids = new List<long>();
|
|
|
|
var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);
|
|
|
|
teams.DoForEach(team =>
|
|
{
|
|
if(team.Oid is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var customer = FindCustomerOfTeam(team.Oid.Value);
|
|
|
|
teamCustomerOids.AddRangeIfElementsNotIn(customer.Where(w => w.Oid.HasValue).Select(c => c.Oid.Value));
|
|
});
|
|
|
|
//foreach (var customerOid in customerOids.Where(customerOid => !teamCustomerOids.Contains(customerOid)))
|
|
//{
|
|
// teamCustomerOids.Add(customerOid);
|
|
//}
|
|
|
|
return lCriteria.Add(Restrictions.In(nameof(Customer.Oid), teamCustomerOids.ToArray())).List<Customer>().ToList();
|
|
}
|
|
|
|
// Der ApplicationUser darf nur seine eigenen Klienten sehen
|
|
return lCriteria.Add(Restrictions.In(nameof(Customer.Oid), customerOids.ToArray())).List<Customer>().ToList();
|
|
}
|
|
|
|
public IList<long> FindFamilyMemberOids()
|
|
{
|
|
var q = Session.CreateSQLQuery("SELECT personoid FROM customer2person where istfamilie = 1");
|
|
return q.List<long>();
|
|
}
|
|
|
|
public IList FindCustomerOid2Persons(IList<long> personOids)
|
|
{
|
|
if(personOids == null || personOids.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
String oidList = "";
|
|
foreach(var oid in personOids)
|
|
{
|
|
if(oidList.Length > 0)
|
|
{
|
|
oidList += ",";
|
|
}
|
|
|
|
oidList += String.Format("{0}", oid);
|
|
}
|
|
|
|
return GetSqlResult("SELECT oid,personoid,customeroid,istfamilie FROM customer2person where personoid in (" + oidList + ")");
|
|
|
|
}
|
|
|
|
public List<SchedulerAppointment> FindActiveAppointmentsForCustomers(List<long> customerOids, DateTime startDate, DateTime endDate)
|
|
{
|
|
var customerOidSqlString = string.Empty;
|
|
customerOids.DoForEach(oid => customerOidSqlString += $"{oid},");
|
|
customerOidSqlString = customerOidSqlString.Trim(',');
|
|
|
|
var sqlQuery = $" {nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({customerOidSqlString})) ";
|
|
var customerCriterion = Expression.Sql(sqlQuery);
|
|
|
|
var between = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));
|
|
|
|
var criteria = CreateCriteriaIsActive<SchedulerAppointment>()
|
|
.Add(customerCriterion)
|
|
.Add(between)
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), false));
|
|
|
|
return criteria.List<SchedulerAppointment>().ToList();
|
|
}
|
|
|
|
public List<SchedulerAppointment> LoadFilteredAllActiveAppointments(long employeeOid, DateTime start, DateTime end, List<long> customerOids)
|
|
{
|
|
var appointments = LoadFilteredAppointments(
|
|
true,
|
|
employeeOid,
|
|
start, end,
|
|
new List<long>(),
|
|
customerOids,
|
|
new List<long>(),
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true);
|
|
|
|
return appointments.ToList();
|
|
}
|
|
|
|
public List<ServiceRecord> FindServiceRecordsForFlsAuslastungsauswertungByCustomerAndEmployees(long? customerOid, List<long> employeeOids, DateTime start, DateTime end, bool onlyBillableCategories)
|
|
{
|
|
var c = CreateCriteriaIsActive<ServiceRecord>().Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid));
|
|
|
|
c.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids));
|
|
|
|
var betweenCriterion = CreateBetweenDateTimesCriterion(start, end, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));
|
|
|
|
c.Add(betweenCriterion);
|
|
|
|
if(onlyBillableCategories)
|
|
{
|
|
c.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("sc." + ServiceCategory.PropertyName_IsBillable, true));
|
|
}
|
|
|
|
return c.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public IList<GeschenkterUrlaubstag> FindGeschenkteUrlaubstageByEmpOid(long empOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<GeschenkterUrlaubstag>()
|
|
.Add(Restrictions.Eq("Employee", empOid));
|
|
|
|
return criteria.List<GeschenkterUrlaubstag>();
|
|
}
|
|
|
|
public IList<GeschenkterUrlaubstag> FindGeschenkteUrlaubstageByYear(int year)
|
|
{
|
|
DateTime start = new DateTime(year, 1, 1).AddTicks(-1);
|
|
DateTime end = new DateTime(year, 12, 31).AddDays(1).AddTicks(-1);
|
|
|
|
var criteria = CreateCriteriaIsActive<GeschenkterUrlaubstag>()
|
|
.Add(Restrictions.Between("Date", start, end));
|
|
|
|
return criteria.List<GeschenkterUrlaubstag>();
|
|
}
|
|
|
|
public List<ServiceRecord> GetActiveServiceRecordsBySupportConceptWithServiceCategoryForCustomer(List<long> customerOids, long serviceCategoryOid, int month, int year)
|
|
{
|
|
var c = CreateCriteriaIsActive<SupportConcept>()
|
|
.Add(Restrictions.In(nameof(SupportConcept.Customer) + ".Oid", customerOids.ToArray()))
|
|
.CreateAlias(SupportConcept.PropertyName_ServiceAccountings, "sa", JoinType.InnerJoin)
|
|
.CreateAlias("sa." + nameof(ServiceAccounting.ServiceDescription), "sd", JoinType.InnerJoin)
|
|
.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "cat", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq("cat.Oid", serviceCategoryOid));
|
|
|
|
var c2 = CreateCriteriaIsActive<SupportConcept>()
|
|
.Add(Restrictions.In(nameof(SupportConcept.Customer) + ".Oid", customerOids.ToArray()))
|
|
.Add(Restrictions.IsEmpty(nameof(SupportConcept.ServiceAccountings)));
|
|
|
|
var supportConcepts = c.List<SupportConcept>().ToList();
|
|
supportConcepts.AddRangeIfElementsNotIn(c2.List<SupportConcept>());
|
|
|
|
var start = new DateTime(year, month, 1, 0, 0, 0);
|
|
var end = start.AddMonths(1).AddSeconds(-1);
|
|
|
|
var criteria = CreateCriteriaIsActive<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.CustomerOid), customerOids.ToArray()))
|
|
.Add(CreateBetweenDateTimesCriterion(start, end, "Start", "End"))
|
|
.Add(Restrictions.In(nameof(ServiceRecord.SupportConcept) + ".Oid", supportConcepts.Select(sc => sc.Oid).ToArray()));
|
|
|
|
return criteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public List<Customer> GetCustomersForEmployeeWithServiceRecordsInInterval(DateTime start, DateTime end, long employeeOid)
|
|
{
|
|
var result = new List<Customer>();
|
|
|
|
// Customers aus Zeitraum, die ServiceRecords haben, wo der Employee dabei ist.
|
|
var serviceRecords = FindEmployeeServiceRecords(employeeOid, new DateTimeSpan(start, end), null, null);
|
|
|
|
serviceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr?.Customer != null)
|
|
{
|
|
result.AddIfNotIn(sr.Customer);
|
|
}
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<Customer> GetCustomersForTeamWithServiceRecordsInInterval(DateTime start, DateTime end, List<long> employeeOids)
|
|
{
|
|
var result = new List<Customer>();
|
|
|
|
var serviceRecords = FindEmployeeServiceRecords(employeeOids, new DateTimeSpan(start, end));
|
|
|
|
serviceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr?.Customer != null)
|
|
{
|
|
result.AddIfNotIn(sr.Customer);
|
|
}
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<ServiceRecord> FindEmployeeServiceRecords(List<long> employeeOids, DateTimeSpan span)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids));
|
|
|
|
if(span != null)
|
|
{
|
|
lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, span.StartDateTime, span.EndDateTime));
|
|
}
|
|
|
|
var result = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IList<DienstInfo> FindDiensteForWohnheim(long? whOid)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<DienstInfo>()
|
|
.Add(Restrictions.Or(Restrictions.Eq("Wohnheim", whOid), Restrictions.IsNull("Wohnheim")));
|
|
|
|
return criteria.List<DienstInfo>(); // Hier fliegt man raus
|
|
}
|
|
|
|
public long? GetActiveMedVerListOidForCustomer(long customerOid)
|
|
{
|
|
// Gültig und MedListType = 0
|
|
return GetActiveMedListByTypeForCustomer(customerOid, false);
|
|
}
|
|
|
|
public long? GetActiveMedListByTypeForCustomer(long customerOid, bool isBedarfsmedikation)
|
|
{
|
|
var criteria = CreateCriteria<Medikamentenverordnungsliste>()
|
|
.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.Gueltig), true))
|
|
.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.Customer) + ".Oid", customerOid))
|
|
.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.MedListType), isBedarfsmedikation));
|
|
|
|
var list = criteria.UniqueResult<Medikamentenverordnungsliste>();
|
|
|
|
return list?.Oid;
|
|
}
|
|
|
|
public List<SchedulerAppointment> LoadOccurrencesByRecurrenceId(string recurrenceId)
|
|
{
|
|
var criteria = CreateCriteria<SchedulerAppointment>()
|
|
.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere));
|
|
|
|
var list = criteria.List<SchedulerAppointment>();
|
|
|
|
return list.ToList();
|
|
}
|
|
|
|
// TODO: Intervalle werden als frei angezeigt, wenn sie am Ende eines Tages sind und sich mit Serienterminen überschneiden
|
|
public Dictionary<DateTime, List<DateTimeSpan>> FindAppointmentsInRange(int duration, DateTime intervalStart, DateTime intervalEnd, List<long> resourceOids, List<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, int intervalBuffer = 30, bool skipWeekends = true)
|
|
{
|
|
var result = new List<SchedulerAppointment>();
|
|
var intervals = IntervalFinderHelper.CreateIntervals(duration, intervalStart, intervalEnd, skipWeekends, intervalBuffer);
|
|
|
|
// Das subset enthält die zu prüfenden Tage im angegebenen Intervall.
|
|
// 04.12.2023 15:00 bis 06.12.2023 12:00 wären 04.12.2023, 05.12.2023, 06.12.2023 im subset.
|
|
var subset = IntervalFinderHelper.GenereateIntervalsForChecking(intervalStart, intervalEnd);
|
|
|
|
// Es werden im subset nach überschneidenden Terminen gesucht.
|
|
//
|
|
foreach(var dts in subset)
|
|
{
|
|
var start = dts.StartDate.MergeDatesByDate(intervalStart);
|
|
var end = dts.EndDate.MergeDatesByDate(intervalEnd);
|
|
|
|
var apptmts = LoadAppointmentsForIntervalFinder(start, end, resourceOids, customerOids, employeeOids, loggedInEmployeeOid, skipWeekends);
|
|
|
|
result.AddRangeIfElementsNotIn(apptmts);
|
|
}
|
|
|
|
/*
|
|
Normal = 0,
|
|
Pattern = 1,
|
|
Occurrence = 2,
|
|
ChangedOccurrence = 3,
|
|
DeletedOccurrence = 4
|
|
*/
|
|
|
|
var changedOccurrences = result.Where(a => a.Type == 3).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
var deletedOccurrences = result.Where(a => a.Type == 4).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
|
|
var kek = IntervalFinderHelper.GetRecurrencesForIntervalFinder(result, intervalStart, intervalEnd, changedOccurrences, deletedOccurrences, skipWeekends);
|
|
|
|
result.AddRange(kek);
|
|
|
|
var freeIntervals = new List<DateTimeSpan>();
|
|
|
|
if(intervals.Count > 0)
|
|
{
|
|
if(result.Count > 0)
|
|
{
|
|
foreach(var interval in intervals)
|
|
{
|
|
if(!result.Any(a => a.StartDate.HasValue && a.EndDate.HasValue && a.StartDate.Value.IsInInterval(a.EndDate.Value, interval.StartDate, interval.EndDate)))
|
|
{
|
|
freeIntervals.Add(interval);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return IntervalFinderHelper.CreateFreeIntervalsDictionary(intervals);
|
|
}
|
|
}
|
|
|
|
return IntervalFinderHelper.CreateFreeIntervalsDictionary(freeIntervals);
|
|
}
|
|
|
|
public Dictionary<DateTimeSpan, Dictionary<DateTime, bool>> FindAppointmentsInRangeForIntervalFinder(int duration, DateTime intervalStart, DateTime intervalEnd, List<long> resourceOids, List<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, int intervalBuffer = 30, bool skipWeekends = true)
|
|
{
|
|
var result = new List<SchedulerAppointment>();
|
|
|
|
var intervals = IntervalFinderHelper.CreateIntervals(duration, intervalStart, intervalEnd, skipWeekends, intervalBuffer);
|
|
|
|
// Das subset enthält die zu prüfenden Tage im angegebenen Intervall.
|
|
// 04.12.2023 15:00 bis 06.12.2023 12:00 wären 04.12.2023, 05.12.2023, 06.12.2023 im subset.
|
|
var subset = IntervalFinderHelper.GenereateIntervalsForChecking(intervalStart, intervalEnd);
|
|
|
|
// Es werden im subset nach überschneidenden Terminen gesucht.
|
|
foreach(var dts in subset)
|
|
{
|
|
var start = dts.StartDate.MergeDatesByDate(intervalStart);
|
|
var end = dts.EndDate.MergeDatesByDate(intervalEnd);
|
|
|
|
var apptmts = LoadAppointmentsForIntervalFinder(start, end, resourceOids, customerOids, employeeOids, loggedInEmployeeOid, skipWeekends);
|
|
|
|
result.AddRangeIfElementsNotIn(apptmts);
|
|
}
|
|
|
|
/*
|
|
Normal = 0,
|
|
Pattern = 1,
|
|
Occurrence = 2,
|
|
ChangedOccurrence = 3,
|
|
DeletedOccurrence = 4
|
|
*/
|
|
|
|
var changedOccurrences = result.Where(a => a.Type == 3).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
var deletedOccurrences = result.Where(a => a.Type == 4).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
|
|
var kek = IntervalFinderHelper.GetRecurrencesForIntervalFinder(result, intervalStart, intervalEnd, changedOccurrences, deletedOccurrences, skipWeekends);
|
|
|
|
result.AddRange(kek);
|
|
|
|
var freeIntervals = new List<DateTimeSpan>();
|
|
|
|
if(intervals.Count > 0)
|
|
{
|
|
if(result.Count > 0)
|
|
{
|
|
foreach(var interval in intervals)
|
|
{
|
|
if(!result.Any(a => a.StartDate.HasValue && a.EndDate.HasValue && a.StartDate.Value.IsInInterval(a.EndDate.Value, interval.StartDate, interval.EndDate)))
|
|
{
|
|
freeIntervals.Add(interval);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return IntervalFinderHelper.CreateFreeIntervals(intervals, intervalStart, intervalEnd, intervalBuffer, duration);
|
|
}
|
|
}
|
|
|
|
return IntervalFinderHelper.CreateFreeIntervals(freeIntervals, intervalStart, intervalEnd, intervalBuffer, duration);
|
|
}
|
|
|
|
private IEnumerable<SchedulerAppointment> LoadAppointmentsForIntervalFinder(DateTime intervalStart, DateTime intervalEnd, IReadOnlyCollection<long> resourceOids, IReadOnlyCollection<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, bool skipWeekends)
|
|
{
|
|
var result = new List<SchedulerAppointment>();
|
|
|
|
if(intervalStart < intervalEnd)
|
|
{
|
|
var intervals = IntervalFinderHelper.GenerateIntervalsForCriteria(intervalStart, intervalEnd, skipWeekends);
|
|
|
|
var intervalRecurrenceCriterias = IntervalFinderHelper.CreateIntervalRecurrenceCriterias(intervals, skipWeekends);
|
|
|
|
var or = CreateOrCriteria(intervalRecurrenceCriterias);
|
|
|
|
var criteria = CreateCriteriaIsActiveWithAlias<SchedulerAppointment>("sa")
|
|
.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true)));
|
|
|
|
if(intervals.Count > 0)
|
|
{
|
|
if(intervals.Count > 1)
|
|
{
|
|
var criterionList = new List<ICriterion>();
|
|
|
|
foreach(var dts in intervals)
|
|
{
|
|
criterionList.AddIfNotIn(
|
|
Restrictions.Or(
|
|
Restrictions.Between(nameof(SchedulerAppointment.StartDate), dts.StartDate, dts.EndDate),
|
|
Restrictions.Or(
|
|
Restrictions.Between(nameof(SchedulerAppointment.EndDate), dts.StartDate, dts.EndDate),
|
|
Restrictions.And(
|
|
Restrictions.Lt(nameof(SchedulerAppointment.StartDate), dts.StartDate),
|
|
Restrictions.Gt(nameof(SchedulerAppointment.EndDate), dts.EndDate)))
|
|
));
|
|
}
|
|
|
|
criteria.Add(Restrictions.Or(or, CreateOrCriteria(criterionList)));
|
|
}
|
|
else
|
|
{
|
|
var dts = intervals.FirstOrDefault();
|
|
|
|
if(dts != null)
|
|
{
|
|
var cri = Restrictions.Or(
|
|
Restrictions.Between(nameof(SchedulerAppointment.StartDate), dts.StartDate, dts.EndDate),
|
|
Restrictions.Or(
|
|
Restrictions.Between(nameof(SchedulerAppointment.EndDate), dts.StartDate, dts.EndDate),
|
|
Restrictions.And(
|
|
Restrictions.Lt(nameof(SchedulerAppointment.StartDate), dts.StartDate),
|
|
Restrictions.Gt(nameof(SchedulerAppointment.EndDate), dts.EndDate)))
|
|
);
|
|
|
|
criteria.Add(Restrictions.Or(or, cri));
|
|
}
|
|
}
|
|
}
|
|
|
|
ICriterion resourceCriterion = null;
|
|
ICriterion customerCriterion = null;
|
|
|
|
if(employeeOids.Count == 0)
|
|
{
|
|
employeeOids.Add(loggedInEmployeeOid);
|
|
}
|
|
|
|
var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
|
|
.Add(Restrictions.In(nameof(Employee2SchedulerAppointment.Employee) + ".Oid", employeeOids))
|
|
.SetProjection(Projections.Property(nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid)));
|
|
var employee2SchedCrit = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), detachedCriteria1);
|
|
|
|
var originatorCrit = Restrictions.In(nameof(SchedulerAppointment.Originator), employeeOids);
|
|
|
|
var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
|
|
.SetProjection(Projections.Property(nameof(BeWoEntityBase.Oid)))
|
|
.Add(Restrictions.EqProperty("e2s2." + nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid), "sa.Oid"));
|
|
|
|
var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);
|
|
|
|
var and = Restrictions.And(originatorCrit, employee2SchedCrit2);
|
|
|
|
var employeeCriterion = Restrictions.Or(employee2SchedCrit, and);
|
|
|
|
if(customerOids?.Count > 0)
|
|
{
|
|
var customerSql = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({customerOids.ToSeparatedString(",")}))";
|
|
customerCriterion = Expression.Sql(customerSql);
|
|
}
|
|
|
|
if(resourceOids?.Count > 0)
|
|
{
|
|
var resourceSql = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({resourceOids.ToSeparatedString(",")}))";
|
|
resourceCriterion = Expression.Sql(resourceSql);
|
|
}
|
|
|
|
var listOfCriterias = new List<ICriterion>
|
|
{
|
|
employeeCriterion,
|
|
customerCriterion,
|
|
resourceCriterion
|
|
};
|
|
|
|
if(listOfCriterias.Count > 0)
|
|
{
|
|
var orCriteria = CreateOrCriteria(listOfCriterias);
|
|
|
|
if(orCriteria != null)
|
|
{
|
|
criteria.Add(orCriteria);
|
|
}
|
|
}
|
|
|
|
var criteriaAsString = criteria.ToString();
|
|
|
|
var appointments = criteria.List<SchedulerAppointment>().ToList();
|
|
|
|
result.AddRange(appointments);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string GetGeneratedSql(ICriteria criteria)
|
|
{
|
|
var criteriaImpl = (CriteriaImpl) criteria;
|
|
var sessionImpl = (SessionImpl) criteriaImpl.Session;
|
|
var factory = (SessionFactoryImpl) sessionImpl.SessionFactory;
|
|
var implementors = factory.GetImplementors(criteriaImpl.EntityOrClassName);
|
|
var loader = new CriteriaLoader((IOuterJoinLoadable) factory.GetEntityPersister(implementors[0]), factory, criteriaImpl, implementors[0], sessionImpl.EnabledFilters);
|
|
|
|
return loader.SqlString.ToString();
|
|
}
|
|
|
|
public long GetMaxOidFromFileAttachment()
|
|
{
|
|
var q = Session.CreateSQLQuery("select max(oid) from fileattachment");
|
|
return q.List<long>().First();
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> GetAllAbsenceTimesInIntervalForCustomers(DateTime start, DateTime end, List<long> customerOids)
|
|
{
|
|
// Wenn das Enddatum null ist, wird das Ende des Intervalls als Enddatum gesetzt (Ist ja eh read-only).
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(Restrictions.IsNotNull(nameof(AbsenceTime.CustomerOid)))
|
|
.Add(Restrictions.Or
|
|
(Restrictions.Or(Restrictions.Or(
|
|
Restrictions.And(Restrictions.Ge(AbsenceTime.PropertyName_Start, start), Restrictions.Le(AbsenceTime.PropertyName_Start, end)),
|
|
Restrictions.Eq(AbsenceTime.PropertyName_Start, start)
|
|
), Restrictions.And(Restrictions.Le(AbsenceTime.PropertyName_Start, start), Restrictions.IsNull(AbsenceTime.PropertyName_End))
|
|
), Restrictions.And(Restrictions.Lt(AbsenceTime.PropertyName_Start, start), Restrictions.Gt(AbsenceTime.PropertyName_End, start)))
|
|
)
|
|
.Add(Restrictions.In(nameof(AbsenceTime.CustomerOid), customerOids));
|
|
|
|
var absenceTimes = criteria.List<AbsenceTime>();
|
|
|
|
return criteria.List<AbsenceTime>();
|
|
}
|
|
|
|
public IEnumerable<AbsenceTime> GetAllEmployeeAbsenceTimesInIntervalForEmployee(DateTime start, DateTime end, List<long> employeeOids)
|
|
{
|
|
// Wenn das Enddatum null ist, wird das Ende des Intervalls als Enddatum gesetzt (Ist ja eh read-only).
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(Restrictions.IsNotNull(nameof(AbsenceTime.EmployeeOid)))
|
|
.Add(Restrictions.Or
|
|
(Restrictions.Or(Restrictions.Or(
|
|
Restrictions.And(Restrictions.Ge(AbsenceTime.PropertyName_Start, start), Restrictions.Le(AbsenceTime.PropertyName_Start, end)),
|
|
Restrictions.Eq(AbsenceTime.PropertyName_Start, start)
|
|
), Restrictions.And(Restrictions.Le(AbsenceTime.PropertyName_Start, start), Restrictions.IsNull(AbsenceTime.PropertyName_End))
|
|
), Restrictions.And(Restrictions.Lt(AbsenceTime.PropertyName_Start, start), Restrictions.Gt(AbsenceTime.PropertyName_End, start)))
|
|
)
|
|
.Add(Restrictions.In(nameof(AbsenceTime.EmployeeOid), employeeOids));
|
|
|
|
return criteria.List<AbsenceTime>();
|
|
}
|
|
|
|
public List<Customer> FindAllCustomersForEmployee(long? employeeOid, CustomerFilterEnum customerFilter)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current?.User != null ? LoggedInUserOperationContextExt.Current.User : SessionFacade.LoggedInUser;
|
|
}
|
|
|
|
var criteria = CreateCriteria<Customer>();
|
|
|
|
// Der ApplicationUser darf alles sehen
|
|
var viewAllRights = new List<UserRightType> { UserRightType.CustomerView_View };
|
|
|
|
if(user.CheckForAtLeastOneRight(viewAllRights) && customerFilter == CustomerFilterEnum.All)
|
|
{
|
|
return criteria.List<Customer>().ToList();
|
|
}
|
|
|
|
var ownCustomerOids = user.Employee?.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList() ?? new List<long>();
|
|
|
|
var customerOids = new List<long>();
|
|
|
|
// Der ApplicationUser darf die Klienten seiner Teams sehen
|
|
if(user.CheckForRight(UserRightType.Customer_ViewMyTeams) && (customerFilter == CustomerFilterEnum.TeamCustomer || customerFilter == CustomerFilterEnum.All) && (user.Employee?.Oid.HasValue ?? false))
|
|
{
|
|
var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);
|
|
|
|
teams.DoForEach(team =>
|
|
{
|
|
if(team.Oid is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var customer = FindCustomerOfTeam(team.Oid.Value);
|
|
|
|
customerOids.AddRangeIfElementsNotIn(customer.Where(w => w.Oid.HasValue).Select(c => c.Oid.Value));
|
|
});
|
|
}
|
|
|
|
// Der ApplicationUser darf seine eigenen Klienten sehen.
|
|
if(user.CheckForRight(UserRightType.Customer_ViewMyCustomers) && (customerFilter == CustomerFilterEnum.All || customerFilter == CustomerFilterEnum.MyCustomer))
|
|
{
|
|
customerOids.AddRangeIfElementsNotIn(ownCustomerOids);
|
|
}
|
|
|
|
var visibleCustomers = criteria.Add(Restrictions.In(nameof(Customer.Oid), customerOids.ToArray())).List<Customer>().ToList();
|
|
|
|
return visibleCustomers;
|
|
}
|
|
|
|
public IList<Employee> FindAllEmployeesForEmployee(long? employeeOid)
|
|
{
|
|
ApplicationUser user;
|
|
|
|
if(employeeOid.HasValue)
|
|
{
|
|
var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
|
|
user = FindUserForEmployee(employee);
|
|
}
|
|
else
|
|
{
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = LoggedInUserOperationContextExt.Current.User;
|
|
}
|
|
else
|
|
{
|
|
user = SessionFacade.LoggedInUser;
|
|
}
|
|
}
|
|
|
|
if(user.Employee.Oid == null)
|
|
{
|
|
return new List<Employee>();
|
|
}
|
|
|
|
var rights = new List<UserRightType>();
|
|
|
|
user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));
|
|
|
|
var criteria = CreateCriteria<Employee>();
|
|
|
|
if(rights.Contains(UserRightType.EmployeeView_View))
|
|
{
|
|
return criteria.List<Employee>().ToList();
|
|
}
|
|
|
|
var result = new List<Employee>();
|
|
|
|
if(rights.Contains(UserRightType.Employee_AllowViewOwnEmployees))
|
|
{
|
|
result.AddIfNotIn(user.Employee);
|
|
}
|
|
|
|
if(rights.Contains(UserRightType.Employee_AllowViewOwnTeam))
|
|
{
|
|
var leadingTeams = user.Employee.LeadingTeams;
|
|
|
|
leadingTeams.DoForEach(team =>
|
|
{
|
|
result.AddIfNotIn(team.Leader);
|
|
|
|
result.AddRangeIfElementsNotIn(team.MemberList);
|
|
});
|
|
|
|
var teams = FindTeamsOfEmployee(user.Employee.Oid.Value);
|
|
|
|
teams.DoForEach(team =>
|
|
{
|
|
result.AddIfNotIn(team.Leader);
|
|
|
|
result.AddRangeIfElementsNotIn(team.MemberList);
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<SchedulerAppointment> LoadAppointmentsWithServiceRecords(List<long> serviceRecordOids)
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>()
|
|
.CreateAlias(nameof(SchedulerAppointment.ServiceRecordList), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()))
|
|
.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
return c.List<SchedulerAppointment>().ToList();
|
|
}
|
|
|
|
/*
|
|
* public bool HasConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
|
|
{
|
|
// Prüfen, ob alle ServiceRecords mit ein und derselben Unterschrift verknüpft sind.
|
|
// Eine Unterschrift kann mehrere ServiceRecords in der LinkListe haben, die nicht in der zu prüfenden Oid-Liste sind.
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
var signatures = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
var result = false;
|
|
|
|
if(serviceRecordOids.Any() && signatures.Any())
|
|
{
|
|
var blubb = new List<long>();
|
|
signatures.DoForEach(s =>
|
|
{
|
|
s.ServiceRecords.DoForEach(sr =>
|
|
{
|
|
if(sr.Oid.HasValue)
|
|
{
|
|
blubb.AddIfNotIn(sr.Oid.Value);
|
|
}
|
|
});
|
|
});
|
|
|
|
result = serviceRecordOids.ContainsSameItemsAs(blubb);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
|
|
public bool CheckForConfirmationReceiptSignatureForServiceRecord(long serviceRecordOid, SignatureType signatureType)
|
|
{
|
|
var critreria = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecords", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq($"serviceRecords.{nameof(BeWoEntityBase.Oid)}", serviceRecordOid));
|
|
|
|
var signature = critreria.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
return signature.Count == 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft anhand der Oids von Ressourcen deren Verfügbarkeit in einem Zeitraum.
|
|
/// Gibt die nicht verfügbaren Ressourcen und Mitarbeiter, die sie gebucht aben zurück für eine detaillierte Fehlermeldung.
|
|
/// </summary>
|
|
/// <param name="resourceOids">Die Oids der zu überprüfenden Ressourcen</param>
|
|
/// <param name="start">Anfang des zu prüfenden Intervalls</param>
|
|
/// <param name="end">Ende des zu prüfenden Intervalls</param>
|
|
/// <param name="selectedAppointmentOid">Die Oid des Termins</param>
|
|
/// <param name="recurrenceId">Recurrence Id, falls es sich um einen Serientermin handelt, der keine eigene Oid hat.</param>
|
|
/// <param name="occurrenceIndex">Occurrence-Index des Serientermins ohne eigene Oid</param>
|
|
/// <returns>Die im angegebenen Zeitraum belegten Ressourcen mit den Mitarbeitern, die sie gebucht haben</returns>
|
|
public List<SchedulerAppointment> FindAppointmentsByResourcesInInterval(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid, Guid? recurrenceId = null, int? occurrenceIndex = null)
|
|
{
|
|
var betweenCriterion = CreateBetweenDateTimesCriterion(start, end, "StartDate", "EndDate");
|
|
|
|
var c2 = CreateCriteriaIsActive<SchedulerAppointment>()
|
|
//.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.Type), 4)))
|
|
.Add(betweenCriterion);
|
|
|
|
|
|
if(!(selectedAppointmentOid is null))
|
|
{
|
|
c2.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid)));
|
|
}
|
|
|
|
c2.CreateAlias(nameof(SchedulerAppointment.ResourceList), "resources", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"resources.{nameof(BeWoEntityBase.Oid)}", resourceOids));
|
|
|
|
var tempAppointments = c2.List<SchedulerAppointment>().ToList();
|
|
|
|
var isBeingUpdatedToNormalAppointment = false;
|
|
Guid? recurrenceIdToIgnore = null;
|
|
if(selectedAppointmentOid.HasValue)
|
|
{
|
|
// Das Pattern wird geladen, bzw. mit der Ausnahme mit Index 0 verglichen
|
|
// Wird die Serie in einen Einzeltermin geändert und es existiert eine Ausnahme mit Index 0, sollte die Ausnahme behalten werden und nicht der Root-Termin
|
|
var original = DAOFactory.GenericDAO.LoadByID<SchedulerAppointment>(selectedAppointmentOid.Value);
|
|
var originalRecurrenceId = original?.GetRecurrenceId();
|
|
|
|
if(!(originalRecurrenceId is null) && IsNullOrWhiteSpace(recurrenceId?.ToString()))
|
|
{
|
|
isBeingUpdatedToNormalAppointment = true;
|
|
recurrenceIdToIgnore = originalRecurrenceId;
|
|
}
|
|
}
|
|
|
|
var appointments = tempAppointments.Where(appointment =>
|
|
{
|
|
if(appointment.RecurrenceInfo is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var recId2 = appointment.GetRecurrenceIdAndIndex(out var index);
|
|
return !((recurrenceId?.Equals(recId2) ?? false) && occurrenceIndex == index);
|
|
}).ToList();
|
|
|
|
|
|
var deletedOccurrences = appointments.Where(app => app.Type == 4).Select(app => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
var changedOccurrences = appointments.Where(app => app.Type == 3).Select(app => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
|
|
var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));
|
|
|
|
var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().ToList();
|
|
|
|
if(isBeingUpdatedToNormalAppointment)
|
|
{
|
|
recurringAppointments = recurringAppointments.Where(root => FilterRootAppointment(root, recurrenceIdToIgnore)).ToList();
|
|
|
|
appointments = appointments.Where(root => FilterRootAppointment(root, recurrenceIdToIgnore)).ToList();
|
|
}
|
|
|
|
recurringAppointments = recurringAppointments.Where(s => s.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
|
|
|
|
foreach(var appointment in recurringAppointments)
|
|
{
|
|
var recurrenceInfo = new RecurrenceInfo();
|
|
recurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
|
|
var occurrenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);
|
|
|
|
var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);
|
|
|
|
if(pattern is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pattern.RecurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
pattern.Start = pattern.RecurrenceInfo.Start;
|
|
pattern.End = appointment.EndDate.Value;
|
|
|
|
var patternId = pattern.RecurrenceInfo.Id.ToString();
|
|
|
|
var interval = new TimeInterval(start, end);
|
|
|
|
var occurrences = occurrenceCalculator.CalcOccurrences(interval, pattern);
|
|
|
|
foreach(var occurrence in occurrences.GetAppointments(interval))
|
|
{
|
|
if(appointment.EndDate is null || appointment.StartDate is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Terminindex in der Serie
|
|
var index = occurrence.RecurrenceIndex;
|
|
|
|
// Das Ende ist offen, da die Terminserie kein Ende hat. Deshalb wird das Ende berechnet.
|
|
var duration = (appointment.EndDate.Value - appointment.StartDate.Value).TotalMinutes;
|
|
|
|
var guidParsingSuccessful = Guid.TryParse(occurrence.RecurrenceInfo?.Id?.ToString(), out var occurrenceGuid);
|
|
|
|
// Der generierte Serientermin muss sich zeitlich mit dem neuen Termin überschneiden
|
|
// und darf nicht in der Liste der geänderten Serientermine oder der Liste der gelöschten Serientermine sein.
|
|
var isInIntervalTest = start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration));
|
|
|
|
if(!isInIntervalTest ||
|
|
changedOccurrences.Any(changedOccurence => changedOccurence.PatternId.Equals(patternId) && changedOccurence.Index == index) ||
|
|
deletedOccurrences.Any(deletedOccurence => deletedOccurence.PatternId.Equals(patternId) && deletedOccurence.Index == index) ||
|
|
index == occurrenceIndex && guidParsingSuccessful && recurrenceId != null && recurrenceId.Equals(occurrenceGuid))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Prüfen, ob es eine Ausnahme an dem Tag gibt, die zu dem Pattern gehört, um das Pattern auszuschließen
|
|
var relatedAppointments = FindAppointmentsByRecurrenceId(new List<string> { recurrenceInfo.Id.ToString() }, true);
|
|
var relatedAppointmentsInInterval = relatedAppointments.Where(a =>
|
|
{
|
|
if(a.StartDate == null || a.EndDate == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var myStart = a.StartDate.Value.Date;
|
|
var myEnd = a.EndDate.Value.Date;
|
|
|
|
var isInInterval = start.Date.InBetween(myStart.GetShortDateTime(), myEnd, true);
|
|
|
|
return isInInterval && a.Type != 4;
|
|
}).ToList();
|
|
|
|
var hasToStop = false;
|
|
|
|
// Prüfen, ob es sich bei dem Termin für den Überschneidungen gesucht werden, um zu unterscheiden, ob ein Serientermin in einen normalen geändert wird.
|
|
var root = FindRootAppointmentByRecurrenceId(recurrenceInfo.Id.ToString());
|
|
if(root.Oid != null && selectedAppointmentOid != null && root.Oid == selectedAppointmentOid && root.RecurrenceInfo != null && IsNullOrWhiteSpace(recurrenceId?.ToString()))
|
|
{
|
|
hasToStop = true;
|
|
}
|
|
|
|
// Indices und Ids der RecurrenceInfo vergleichen. Stimmen sie überein, dann wird das generiert Serienelement ignoriert.
|
|
if(occurrence.RecurrenceInfo?.Id != null && !hasToStop)
|
|
{
|
|
if(Guid.TryParse(occurrence.RecurrenceInfo.Id.ToString(), out var guid))
|
|
{
|
|
foreach(var relatedAppointment in relatedAppointmentsInInterval)
|
|
{
|
|
var relatedAppointmentRecurrenceId = relatedAppointment.GetRecurrenceIdAndIndex(out var relatedAppointmentRecurrenceIndex);
|
|
|
|
if(relatedAppointmentRecurrenceId != null)
|
|
{
|
|
if(guid.Equals(relatedAppointmentRecurrenceId) && relatedAppointmentRecurrenceIndex.Equals(occurrence.RecurrenceIndex))
|
|
{
|
|
hasToStop = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(hasToStop)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var recurringAppointment = new SchedulerAppointment
|
|
{
|
|
AllDay = occurrence.AllDay,
|
|
CustomerList = appointment.CustomerList,
|
|
Notice = appointment.Notice,
|
|
EmployeeList = appointment.EmployeeList,
|
|
EndDate = occurrence.Start.AddMinutes(duration),
|
|
FormerBookingSequenceOid = appointment.FormerBookingSequenceOid,
|
|
IsPrivate = appointment.IsPrivate,
|
|
Location = appointment.Location,
|
|
Originator = appointment.Originator,
|
|
RecurrenceInfo = occurrence.RecurrenceInfo.ToXml(),
|
|
ReminderInfo = appointment.ReminderInfo,
|
|
ResourceList = appointment.ResourceList,
|
|
StartDate = occurrence.Start,
|
|
Subject = appointment.Subject ?? "",
|
|
Type = appointment.Type
|
|
};
|
|
|
|
appointments.AddIfNotIn(recurringAppointment);
|
|
}
|
|
}
|
|
|
|
return appointments.Where(appointment => appointment.Type != 4).OrderBy(appointment => appointment.StartDate).ToList();
|
|
}
|
|
|
|
private static bool FilterRootAppointment(SchedulerAppointment root, Guid? recurrenceIdToIgnore)
|
|
{
|
|
var recId = root.GetRecurrenceId();
|
|
|
|
if(recId is null || recurrenceIdToIgnore is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return !recId.Equals(recurrenceIdToIgnore);
|
|
}
|
|
|
|
public List<ConfirmationReceiptSignature> LoadAllConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids)
|
|
{
|
|
var c = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var result = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public Dictionary<string, List<string>> CheckResourceAvailabilityWithEmployeeInformation(DateTime start, DateTime end, List<long> resourceOids, long? selectedAppointmentOid, Guid? recurrenceId = null, int occurrenceIndex = 0)
|
|
{
|
|
var appointments = FindAppointmentsByResourcesInInterval(resourceOids, start, end, selectedAppointmentOid, recurrenceId, occurrenceIndex);
|
|
|
|
var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;
|
|
|
|
var result = new Dictionary<string, List<string>>();
|
|
|
|
if(user is null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var loggedInEmployee = user.Employee;
|
|
|
|
var hasRightToViewEmployeeAppointments = user.CheckForRight(UserRightType.KalenderMitarbeitertermineAnsehen);
|
|
var hasRightToViewResourceAppointments = user.CheckForRight(UserRightType.KalenderRessourcentermineAnsehen);
|
|
|
|
var dictionary = new Dictionary<Resource, List<SchedulerAppointment>>();
|
|
|
|
foreach(var appointment in appointments)
|
|
{
|
|
foreach(var resource in appointment.ResourceList)
|
|
{
|
|
dictionary.AddOrUpdateValueInDictionary(resource, appointment);
|
|
}
|
|
}
|
|
|
|
foreach(var resource2Appointments in dictionary)
|
|
{
|
|
foreach(var appointment in resource2Appointments.Value)
|
|
{
|
|
var originator = appointment.Originator;
|
|
var employee2Appointments = appointment.EmployeeList;
|
|
|
|
var isOwnAppointment = (originator?.Equals(loggedInEmployee) ?? false) || employee2Appointments.ToList().Any(e2a => e2a.Employee.Equals(loggedInEmployee));
|
|
|
|
// Wenn isOwnAppointment true ist, darf der Benutzer die Uhrzeiten und die Mitarbeiter sehen. Ansonsten müssen die Rechte geprüft werden.
|
|
if(isOwnAppointment || hasRightToViewEmployeeAppointments) // Es werden Zeit und Mitarbeiter angezeigt
|
|
{
|
|
result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, $"{CreateDateTimeInfoFromAppointment(appointment.StartDate, appointment.EndDate, appointment.AllDay)} von {originator}");
|
|
}
|
|
else if(hasRightToViewResourceAppointments && !hasRightToViewEmployeeAppointments) // Nur die Uhrzeit anzeigen
|
|
{
|
|
result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, $"{CreateDateTimeInfoFromAppointment(appointment.StartDate, appointment.EndDate, appointment.AllDay)}");
|
|
}
|
|
else if(!hasRightToViewEmployeeAppointments) // Es werden weder Zeit noch Mitarbeiter angezeigt
|
|
{
|
|
result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, string.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string CreateDateTimeInfoFromAppointment(DateTime? start, DateTime? end, bool allDay)
|
|
{
|
|
if(start.HasValue && end.HasValue && allDay == false)
|
|
{
|
|
return start.Value.Date == end.Value.Date ? $"{start.Value.ToShortTimeString()} - {end.Value.ToShortTimeString()} " : $"{start.Value:dd.MM.yyyy HH:mm} - {end.Value:dd.MM.yyyy HH:mm} ";
|
|
}
|
|
|
|
if(allDay && start.HasValue && end.HasValue)
|
|
{
|
|
return start.Value.Date == end.Value.Date ? " " : $"{start.Value.ToShortDateString()} - {end.Value.ToShortDateString()} ";
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
public List<ValidationMessage> GetValidationMessagesForMonth(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteria<ValidationMessage>()
|
|
.Add(Restrictions.Gt(ValidationMessage.PropertyName_InsTs, startDate))
|
|
.Add(Restrictions.Lt(ValidationMessage.PropertyName_InsTs, endDate));
|
|
|
|
var list = criteria.List<ValidationMessage>();
|
|
|
|
return list.ToList();
|
|
}
|
|
|
|
public List<ServiceRecord> GetServiceRecordForTimeSpan(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Gt(ServiceRecord.PropertyName_Start, startDate))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, endDate));
|
|
|
|
var list = criteria.List<ServiceRecord>();
|
|
|
|
return list.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// VERALTET! FindMostRecentSignatureStatusInfoByServiceRecordOid benutzen!
|
|
/// </summary>
|
|
/// <param name="serviceRecordOid"></param>
|
|
/// <returns></returns>
|
|
public ServiceRecordHistory FindMostRecentServiceRecordHistoryEntryByServiceRecordOid(long serviceRecordOid)
|
|
{
|
|
try
|
|
{
|
|
var criteira = CreateCriteria<ServiceRecordHistory>()
|
|
.Add(Restrictions.Eq(nameof(ServiceRecordHistory.ServiceRecordOid), serviceRecordOid))
|
|
.AddOrder(Order.Desc(nameof(ServiceRecordHistory.InsTs)));
|
|
|
|
return criteira.List<ServiceRecordHistory>().FirstOrDefault();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ToDo: Veraltet und wird nicht mehr benutzt!
|
|
public Dictionary<long, ServiceRecordHistory> FindMostRecentServiceRecordHistoryEntryByServiceRecords(List<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecordHistory>()
|
|
.Add(Restrictions.In(nameof(ServiceRecordHistory.ServiceRecordOid), serviceRecordOids))
|
|
.AddOrder(Order.Desc(nameof(ServiceRecordHistory.InsTs)));
|
|
|
|
var historyEntries = criteria.List<ServiceRecordHistory>();
|
|
|
|
var result = new Dictionary<long, ServiceRecordHistory>();
|
|
|
|
foreach(var entry in historyEntries)
|
|
{
|
|
if(entry.ServiceRecordOid.HasValue && result.ContainsKey(entry.ServiceRecordOid.Value) || entry.ServiceRecordOid is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
result.AddIfNotIn(new KeyValuePair<long, ServiceRecordHistory>(entry.ServiceRecordOid.Value, entry));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ToDo: Veraltet und wird nicht mehr benutzt!
|
|
public List<ServiceRecord> FindFormerlyLinkedServiceRecords(long confirmationReceiptSignatureOid, long customerOid, long supportConceptOid, long costBearer2SupportConceptOid, string timeSpanString)
|
|
{
|
|
if(timeSpanString?.Length != 21)
|
|
{
|
|
return new List<ServiceRecord>();
|
|
}
|
|
|
|
var d1 = timeSpanString.Substring(0, 2);
|
|
var m1 = timeSpanString.Substring(3, 2);
|
|
var d2 = timeSpanString.Substring(11, 2);
|
|
var m2 = timeSpanString.Substring(14, 2);
|
|
var year = timeSpanString.Substring(17, 4);
|
|
|
|
var timeSpanStart = DateTime.Parse($"{year}-{m1}-{d1}");
|
|
var timeSpanEnd = DateTime.Parse($"{year}-{m2}-{d2}");
|
|
|
|
// ToDo: Warum wird geprüft, ob der InsTs im Intervall liegt?
|
|
// ToDo: Die ausschließen, die mit einer aktiven ConfirmationReceiptSignature verlinkt sind!
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
//.Add(Restrictions.Between(nameof(ServiceRecord.InsTs), timeSpanStart, timeSpanEnd))
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid))
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.SupportConcept) + ".Oid", supportConceptOid))
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costBearer2SupportConceptOid))
|
|
.Add(Restrictions.Between(nameof(ServiceRecord.Start), timeSpanStart, timeSpanEnd))
|
|
.Add(Restrictions.Between(nameof(ServiceRecord.End), timeSpanStart, timeSpanEnd))
|
|
//.Add(Expression.Sql(new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid})")));
|
|
.Add(Expression.Sql(new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid IN (SELECT ConfirmationReceiptSignatureOid FROM confirmationreceiptsignature WHERE IsActive = 1))")));
|
|
|
|
return criteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public List<ConfirmationReceiptSignature> LoadAllActiveConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids)
|
|
{
|
|
var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));
|
|
|
|
// Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
|
|
c.SetResultTransformer(new DistinctRootEntityResultTransformer());
|
|
|
|
var result = c.List<ConfirmationReceiptSignature>().ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<ServiceRecord> FindFormerlyLinkedServiceRecordsBySignatureOid(long confirmationReceiptSignatureOid)
|
|
{
|
|
var sql = new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid}) AND " +
|
|
$"this_.Oid IN (SELECT ServiceRecordOid FROM servicerecordhistory WHERE CustomerConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid} OR EmployeeConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid})");
|
|
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Expression.Sql(sql));
|
|
|
|
return criteria.List<ServiceRecord>().ToList();
|
|
}
|
|
|
|
public SignatureStateInfoFromServiceRecordHistoryEntry FindMostRecentSignatureStatusInfoByServiceRecordOid(long serviceRecordOid)
|
|
{
|
|
var sqlQuery = Session.CreateSQLQuery($"SELECT * FROM ServiceRecordHistory WHERE ServiceRecordOid = {serviceRecordOid} ORDER BY InsTs DESC LIMIT 1")
|
|
.AddScalar("CustomerConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("EmployeeConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("ServiceRecordSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("CustomerConfirmationReceiptSignatureOid", NHibernateUtil.Int64)
|
|
.AddScalar("EmployeeConfirmationReceiptSignatureOid", NHibernateUtil.Int64);
|
|
|
|
var objectsList = sqlQuery.List<object[]>().ToList();
|
|
|
|
var row = objectsList.FirstOrDefault();
|
|
|
|
if(row is null || row.Length != 5)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var customerConfirmationReceiptSignatureState = (SignatureStateType) row[0];
|
|
var employeeConfirmationReceiptSignatureState = (SignatureStateType) row[1];
|
|
var serviceRecordSignatureStateType = (SignatureStateType) row[2];
|
|
var customerConfirmationReceiptSignatureOid = (long?) row[3];
|
|
var employeeConfirmationReceiptSignatureOid = (long?) row[4];
|
|
|
|
return new SignatureStateInfoFromServiceRecordHistoryEntry(customerConfirmationReceiptSignatureState, employeeConfirmationReceiptSignatureState, serviceRecordSignatureStateType, customerConfirmationReceiptSignatureOid, employeeConfirmationReceiptSignatureOid);
|
|
}
|
|
|
|
public Dictionary<long, SignatureStateInfoFromServiceRecordHistoryEntry> FindMostRecentSignatureStatusInfoByServiceRecords(List<long> serviceRecordOids)
|
|
{
|
|
var result = new Dictionary<long, SignatureStateInfoFromServiceRecordHistoryEntry>();
|
|
|
|
if(serviceRecordOids is null || serviceRecordOids.Count == 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var sqlQuery = Session.CreateSQLQuery($"SELECT * FROM servicerecordhistory WHERE ServiceRecordOid IN ({serviceRecordOids.Aggregate(string.Empty, (current, item) => current + $"{item},").TrimEnd(',')}) ORDER BY InsTs DESC")
|
|
.AddScalar("ServiceRecordOid", NHibernateUtil.Int64)
|
|
.AddScalar("CustomerConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("EmployeeConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("ServiceRecordSignatureStateType", NHibernateUtil.Int32)
|
|
.AddScalar("CustomerConfirmationReceiptSignatureOid", NHibernateUtil.Int64)
|
|
.AddScalar("EmployeeConfirmationReceiptSignatureOid", NHibernateUtil.Int64);
|
|
|
|
var objectsList = sqlQuery.List<object[]>().ToList();
|
|
|
|
foreach(var obj in objectsList)
|
|
{
|
|
if(obj?.Length != 6)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var serviceRecordOid = (long?) obj[0];
|
|
|
|
if(serviceRecordOid is null || result.ContainsKey(serviceRecordOid.Value))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var customerConfirmationReceiptSignatureState = (SignatureStateType) obj[1];
|
|
var employeeConfirmationReceiptSignatureState = (SignatureStateType) obj[2];
|
|
var serviceRecordSignatureStateType = (SignatureStateType) obj[3];
|
|
var customerConfirmationReceiptSignatureOid = (long?) obj[4];
|
|
var employeeConfirmationReceiptSignatureOid = (long?) obj[5];
|
|
|
|
result.AddIfNotIn(new KeyValuePair<long, SignatureStateInfoFromServiceRecordHistoryEntry>(serviceRecordOid.Value, new SignatureStateInfoFromServiceRecordHistoryEntry(customerConfirmationReceiptSignatureState, employeeConfirmationReceiptSignatureState, serviceRecordSignatureStateType, customerConfirmationReceiptSignatureOid, employeeConfirmationReceiptSignatureOid)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#region MoK-Zeiterfassungspagination
|
|
|
|
public IEnumerable<ServiceRecord> FindServiceRecordsForDaysPaginated(long? costBearer2SupportConceptOid, int dayCount, long? employeeOid, int firstResult, int maxResults, out int rowCount)
|
|
{
|
|
var minStart = DateTime.Now.GetShortDateTime().AddDays(-dayCount);
|
|
var criteria = CreateCriteriaIsActive<ServiceRecord>();
|
|
var rowCountCirteria = CreateCriteriaIsActive<ServiceRecord>();
|
|
|
|
if(costBearer2SupportConceptOid.HasValue)
|
|
{
|
|
var groupOidsQuery = Session.CreateSQLQuery($"SELECT MIN(Oid) FROM servicerecord WHERE CostBearer2SupportConceptOid = {costBearer2SupportConceptOid} GROUP BY GroupOid");
|
|
var groupOids = groupOidsQuery.List<long>().ToArray();
|
|
|
|
criteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
|
|
rowCountCirteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
|
|
|
|
criteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
|
|
rowCountCirteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
|
|
}
|
|
else
|
|
{
|
|
criteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
rowCountCirteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
}
|
|
|
|
if(dayCount > 0)
|
|
{
|
|
var intervalStart = minStart;
|
|
var intervalEnd = minStart.AddDays(dayCount + 1).AddSeconds(-1);
|
|
|
|
var timesCriterion = CreateBetweenDateTimesCriterion(intervalStart, intervalEnd, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));
|
|
|
|
criteria.Add(timesCriterion);
|
|
rowCountCirteria.Add(timesCriterion);
|
|
}
|
|
|
|
criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));
|
|
|
|
rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;
|
|
|
|
var serviceRecords = criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();
|
|
|
|
return serviceRecords;
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerPaginated(long pEmployeeOid, long? days, int firstResult, int maxResults, out int rowCount)
|
|
{
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
var rowCountCirteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
if(days is object)
|
|
{
|
|
var intervalStart = DateTime.Today;
|
|
var intervalEnd = intervalStart.AddDays(days.Value + 1).AddSeconds(-1);
|
|
|
|
var timesCriterion = CreateBetweenDateTimesCriterion(intervalStart, intervalEnd, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));
|
|
|
|
criteria.Add(timesCriterion);
|
|
rowCountCirteria.Add(timesCriterion);
|
|
}
|
|
|
|
criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));
|
|
|
|
rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;
|
|
|
|
return criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindServiceRecordsDetailsForLastDaysWithStartEndDatePaginated(long costbearer2SupportConcept, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
|
|
{
|
|
var groupOidsQuery = Session.CreateSQLQuery($"SELECT MIN(Oid) FROM servicerecord WHERE CostBearer2SupportConceptOid = {costbearer2SupportConcept} GROUP BY GroupOid");
|
|
var groupOids = groupOidsQuery.List<long>().ToArray();
|
|
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costbearer2SupportConcept));
|
|
|
|
var rowCountCirteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costbearer2SupportConcept));
|
|
|
|
var max = ende.Date.AddDays(1).AddSeconds(-1);
|
|
|
|
criteria.Add(Restrictions.Ge(nameof(ServiceRecord.Start), start.Date))
|
|
.Add(Restrictions.Le(nameof(ServiceRecord.Start), max));
|
|
|
|
rowCountCirteria.Add(Restrictions.Ge(nameof(ServiceRecord.Start), start.Date))
|
|
.Add(Restrictions.Le(nameof(ServiceRecord.Start), max));
|
|
|
|
criteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
|
|
rowCountCirteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
|
|
|
|
criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));
|
|
|
|
rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;
|
|
|
|
var result = criteria
|
|
.CreateAlias(nameof(ServiceRecord.ValueList), "vl", JoinType.LeftOuterJoin)
|
|
.CreateAlias(nameof(ServiceRecord.ServiceDescription), "sd", JoinType.InnerJoin)
|
|
.CreateAlias($"sd.{nameof(ServiceDescription.ServiceCategory)}", "sc", JoinType.InnerJoin)
|
|
//.CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin)
|
|
//.CreateCriteria("e." + Employee.PropertyName_Person, JoinType.InnerJoin)
|
|
.SetFirstResult(firstResult)
|
|
.SetMaxResults(maxResults)
|
|
.Future<ServiceRecord>();
|
|
|
|
return result;
|
|
}
|
|
|
|
public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerWithStartEndDatePaginated(long pEmployeeOid, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
|
|
{
|
|
|
|
var criteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
var rowCountCirteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
|
|
.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
|
|
|
|
var max = ende.Date.AddDays(1);
|
|
|
|
criteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Le(ServiceRecord.PropertyName_End, max.Date));
|
|
|
|
rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Le(ServiceRecord.PropertyName_End, max.Date));
|
|
|
|
criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));
|
|
|
|
rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;
|
|
|
|
return criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();
|
|
}
|
|
|
|
#endregion
|
|
|
|
public Signature LoadSignatureByTransaktionsOid(long transaktionsOid)
|
|
{
|
|
var criteria = CreateCriteria<Signature>()
|
|
.Add(Restrictions.Eq(nameof(Signature.BargeldtransaktionsOid), transaktionsOid));
|
|
|
|
return criteria.List<Signature>().FirstOrDefault();
|
|
}
|
|
|
|
public List<long> LoadSignatureOidsByTransaktionOid(long transactionOid)
|
|
{
|
|
var criteria = CreateCriteria<Signature>()
|
|
.Add(Restrictions.Eq(nameof(Signature.BargeldtransaktionsOid), transactionOid));
|
|
|
|
return criteria.List<Signature>().Select(s => s.Oid.Value).ToList();
|
|
}
|
|
|
|
public List<Signature> LoadSignaturesByTransactionOids(List<long> transactionOids)
|
|
{
|
|
var criteria = CreateCriteria<Signature>()
|
|
.Add(Restrictions.In(nameof(Signature.BargeldtransaktionsOid), transactionOids));
|
|
|
|
return criteria.List<Signature>().ToList();
|
|
}
|
|
|
|
public List<Bargeldtransaktionshistory> LoadBargeldtransaktionshistoryEntries(long transaktionsOid)
|
|
{
|
|
var criteria = CreateCriteria<Bargeldtransaktionshistory>()
|
|
.Add(Restrictions.Eq(nameof(Bargeldtransaktionshistory.BargeldtransaktionOid), transaktionsOid));
|
|
|
|
return criteria.List<Bargeldtransaktionshistory>().ToList();
|
|
}
|
|
|
|
public int GetNextDatenaustauschreferenz(string datenannahmestelle)
|
|
{
|
|
var criteria = CreateCriteria<GkvTransferProtokoll>()
|
|
.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.SentApp8Success && x.IKDatenannahmestelle == datenannahmestelle))
|
|
.SetProjection(Projections.Max("Datenaustauschreferenz"));
|
|
|
|
var t = criteria.List<int?>().SingleOrDefault();
|
|
|
|
return t + 1 ?? 1;
|
|
}
|
|
|
|
public int GetNextTransfernummer(string datenannahmestelle)
|
|
{
|
|
var criteria = CreateCriteria<GkvTransferProtokoll>()
|
|
.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.SentApp8Success && x.IKDatenannahmestelle == datenannahmestelle))
|
|
.SetProjection(Projections.Max("Transfernummer"));
|
|
|
|
var t = criteria.List<int?>().SingleOrDefault();
|
|
|
|
return t + 1 ?? 0;
|
|
}
|
|
|
|
public List<Organisation> GetAllOrganisationByIKKrankenkasse(string ikkrankenkasse)
|
|
{
|
|
var criteria = CreateCriteria<Organisation>()
|
|
.Add(Restrictions.Where<Organisation>(x => x.IKKrankenkasse == ikkrankenkasse));
|
|
|
|
return criteria.List<Organisation>().ToList();
|
|
}
|
|
|
|
public List<Bargeldtransaktionshistory> LoadBargeldtransaktionshistoryEntriesByTransaktionsOids(List<long> transaktionsOids)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<Bargeldtransaktionshistory>()
|
|
.Add(Restrictions.In(nameof(Bargeldtransaktionshistory.BargeldtransaktionOid), transaktionsOids));
|
|
|
|
return criteria.List<Bargeldtransaktionshistory>().ToList();
|
|
}
|
|
|
|
public List<ValueListEntry> GetGoalCategoriesByOids(List<long> oids)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<ValueListEntry>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
Restrictions.Eq(nameof(ValueListEntry.Type), ValueListEntryType.SupportConceptGoalCategoryType),
|
|
Restrictions.Eq(nameof(ValueListEntry.Type), ValueListEntryType.SupportConceptIndividualGoalCategoryType)))
|
|
.AddOrder(Order.Asc(nameof(ValueListEntry.Value)));
|
|
|
|
return criteria.List<ValueListEntry>().OrderBy(valueListEntry => $"{valueListEntry.Abbreviation}-{valueListEntry.Value}").ToList();
|
|
}
|
|
|
|
public List<SupportConcept> FindSupportConceptsByCostbearer2SupportConceptRelOids(List<long> costbearer2SupportConceptRelOids)
|
|
{
|
|
var criteria = CreateCriteria<SupportConcept>()
|
|
.CreateAlias(nameof(SupportConcept.CostBearer2SupportConceptList), "cb2Sc", JoinType.InnerJoin)
|
|
.Add(Restrictions.In($"cb2Sc.{nameof(BeWoEntityBase.Oid)}", costbearer2SupportConceptRelOids.ToArray()));
|
|
|
|
return criteria.List<SupportConcept>().ToList();
|
|
}
|
|
|
|
public virtual IList<Customer> FindCustomersOfTeams(IEnumerable<long> teamOids)
|
|
{
|
|
return CreateCriteriaIsActiveOrArchived<Customer>()
|
|
.CreateCriteria(nameof(Customer.Team2CustomerList), JoinType.InnerJoin)
|
|
.Add(Restrictions.In(nameof(Team2Customer.TeamOid), teamOids.ToArray()))
|
|
.List<Customer>();
|
|
}
|
|
|
|
public List<Customer> FindCustomersForPaginatedQb(int firstResult, int maxResults, bool checkTeamCustomerRights, DateTime start, DateTime end, out int rowCount)
|
|
{
|
|
var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;
|
|
|
|
var rights = new List<UserRightType>();
|
|
foreach(var userGroup in user.UserGroups)
|
|
{
|
|
rights.AddRangeIfElementsNotIn(userGroup.Rights.Select(rightRelation => rightRelation.RightType));
|
|
}
|
|
|
|
var hasRightCustomerViewView = rights.Contains(UserRightType.CustomerView_View);
|
|
var hasRightCustomerViewMyTeams = rights.Contains(UserRightType.Customer_ViewMyTeams);
|
|
|
|
IList<long> customerOidsWithQb = null;
|
|
ICriteria criteria = CreateCriteriaIsActive<Customer>();
|
|
|
|
if(!hasRightCustomerViewView)
|
|
{
|
|
if(checkTeamCustomerRights && hasRightCustomerViewMyTeams)
|
|
{
|
|
criteria = criteria
|
|
.CreateCriteria(nameof(Customer.Team2CustomerList), JoinType.InnerJoin)
|
|
.Add(Restrictions.In(nameof(Team2Customer.TeamOid), user.Employee.LeadingTeams.Select(team => team.Oid.Value).ToArray()));
|
|
|
|
}
|
|
else
|
|
{
|
|
var allOwnCustomerOids = user.Employee.Employee2CustomerList.Select(e2C => e2C.Customer.Oid.Value).ToList();
|
|
|
|
criteria = criteria
|
|
.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), allOwnCustomerOids));
|
|
}
|
|
}
|
|
|
|
|
|
customerOidsWithQb = FilterCustomerOidsWithQuittierungsbeleg(criteria.List<Customer>().Select(c => c.Oid.Value).Distinct().ToArray(), start, end);
|
|
|
|
var customers = criteria
|
|
.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOidsWithQb.ToArray()))
|
|
.CreateAlias(nameof(Customer.Person), "p", JoinType.InnerJoin)
|
|
.AddOrder(Order.Asc($"p.{nameof(Person.LastName)}"))
|
|
.SetFirstResult(firstResult)
|
|
.SetMaxResults(maxResults)
|
|
.Future<Customer>()
|
|
.ToList();
|
|
|
|
rowCount = customerOidsWithQb.Count;
|
|
return customers;
|
|
}
|
|
|
|
public List<Customer> FindCustomersForPaginatedQbByOids(int firstResult, int maxResults, long[] customerOids, DateTime start, DateTime end, out int rowCount)
|
|
{
|
|
//rowCount = GetRowCountForQuittierungsbelegPagination(customerOids, start, end);
|
|
var list = FilterCustomerOidsWithQuittierungsbeleg(customerOids, start, end);
|
|
rowCount = list.Count;
|
|
|
|
return CreateCriteriaIsActive<Customer>()
|
|
.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), list.ToArray()))
|
|
.CreateAlias(nameof(Customer.Person), "p", JoinType.InnerJoin)
|
|
.AddOrder(Order.Asc($"p.{nameof(Person.LastName)}"))
|
|
.SetFirstResult(firstResult)
|
|
.SetMaxResults(maxResults)
|
|
.Future<Customer>()
|
|
.ToList();
|
|
}
|
|
|
|
private IList<long> FilterCustomerOidsWithQuittierungsbeleg(long[] customerOids, DateTime start, DateTime end)
|
|
{
|
|
if(customerOids.Length == 0)
|
|
{
|
|
return new List<long>();
|
|
}
|
|
|
|
String oidList = "";
|
|
|
|
for(int i = 0; i < customerOids.Length; i++)
|
|
{
|
|
if(oidList.Length > 0)
|
|
{
|
|
oidList += ",";
|
|
}
|
|
|
|
oidList += customerOids[i];
|
|
}
|
|
|
|
var sql = $"select distinct c.oid from customer c inner join servicerecord sr on c.oid = sr.customeroid where c.IsActive = 1 and sr.StartDate >= ':Start' and sr.StartDate < ':End' and c.oid in (:OidList)";
|
|
sql = sql.Replace(":Start", String.Format("{0:yyyy-MM-dd}", start));
|
|
sql = sql.Replace(":End", String.Format("{0:yyyy-MM-dd}", end.Date.AddDays(1)));
|
|
sql = sql.Replace(":OidList", oidList);
|
|
var q = Session.CreateSQLQuery(sql);
|
|
return q.List<long>();
|
|
|
|
//var customerCountWithQuittierungsbelegInSpan = CreateCriteriaIsActive<Customer>()
|
|
// .Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOids))
|
|
// .CreateAlias(nameof(Customer.ServiceRecordList), "sr", JoinType.InnerJoin)
|
|
// .Add(Restrictions.Between($"sr.{nameof(ServiceRecord.Start)}", start, end))
|
|
// .SetProjection(Projections.CountDistinct(nameof(BeWoEntityBase.Oid))).FutureValue<int>().Value;
|
|
|
|
//return customerCountWithQuittierungsbelegInSpan;
|
|
}
|
|
|
|
public long GetServiceRecordCountForServiceCategory(long catOid)
|
|
{
|
|
var sql = $"SELECT COUNT(sr.oid) FROM ServiceRecord sr join ServiceDescription sd on sr.ServiceDescriptionOid = sd.Oid WHERE sd.ServiceCategoryOid = {catOid}";
|
|
var q = Session.CreateSQLQuery(sql);
|
|
return q.List<long>().First();
|
|
}
|
|
|
|
public long GetServiceRecordCountForServiceDescription(long descOid)
|
|
{
|
|
var sql = $"SELECT COUNT(sr.oid) FROM ServiceRecord sr WHERE sr.ServiceDescriptionOid = {descOid}";
|
|
var q = Session.CreateSQLQuery(sql);
|
|
return q.List<long>().First();
|
|
}
|
|
|
|
public string GetGkvRawData(long oid, GkvRawDataType gkvRawData)
|
|
{
|
|
var criteria = CreateCriteria<GkvTransferProtokoll>()
|
|
.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.Oid == oid));
|
|
|
|
if(gkvRawData == GkvRawDataType.Auftragsdatei)
|
|
{
|
|
criteria = criteria.SetProjection(Projections.Property(nameof(GkvTransferProtokoll.Auftragsdatei)));
|
|
}
|
|
else if(gkvRawData == GkvRawDataType.Nutzdatendatei)
|
|
{
|
|
criteria = criteria.SetProjection(Projections.Property(nameof(GkvTransferProtokoll.Nutzdatendatei)));
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(gkvRawData), $"GkvRawDataType \'{gkvRawData}\' unbekannt.");
|
|
}
|
|
|
|
var t = criteria.List<string>().SingleOrDefault();
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
private int GetRowCountForQuittierungsbelegPagination(long[] customerOids, DateTime start, DateTime end)
|
|
{
|
|
var customerCountWithQuittierungsbelegInSpan = CreateCriteriaIsActive<Customer>()
|
|
.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOids))
|
|
.CreateAlias(nameof(Customer.ServiceRecordList), "sr", JoinType.InnerJoin)
|
|
.Add(Restrictions.Between($"sr.{nameof(ServiceRecord.Start)}", start, end.AddDays(1).AddSeconds(-1)))
|
|
.SetProjection(Projections.CountDistinct(nameof(BeWoEntityBase.Oid))).FutureValue<int>().Value;
|
|
|
|
return customerCountWithQuittierungsbelegInSpan;
|
|
}
|
|
|
|
public Bargeldkasse FindBargeldkasseByBargeldtransaktion(long transaktionsoid)
|
|
{
|
|
return CreateCriteria<Bargeldkasse>()
|
|
.CreateAlias(nameof(Bargeldkasse.Bargeldtransaktionen), "t", JoinType.InnerJoin)
|
|
.Add(Restrictions.Eq($"t.{nameof(BeWoEntityBase.Oid)}", transaktionsoid))
|
|
.UniqueResult<Bargeldkasse>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erzeugt einen SignatureHistory-Eintrag auf Basis einer Einzelunterschrift oder einer Bargeldtransaktionsunterschrift.
|
|
/// </summary>
|
|
/// <param name="signature">Unterschriftenobjekt</param>
|
|
/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
|
|
/// <returns></returns>
|
|
public SignatureHistory CreateSignatureHistoryEntry(Signature signature, SignatureEventType signatureEventType)
|
|
{
|
|
if(signature?.ServiceRecordOid is null && signature?.BargeldtransaktionsOid is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ServiceRecord serviceRecord = signature.ServiceRecordOid.HasValue
|
|
? DAOFactory.GenericDAO.GetByID<ServiceRecord>(signature.ServiceRecordOid.Value)
|
|
: null;
|
|
|
|
Bargeldtransaktion bargeldtransaktion = signature.BargeldtransaktionsOid.HasValue
|
|
? DAOFactory.GenericDAO.GetByID<Bargeldtransaktion>(signature.BargeldtransaktionsOid.Value)
|
|
: null;
|
|
|
|
Bargeldkasse bargeldkasse = bargeldtransaktion is object ? DAOFactory.SearchDAO.FindBargeldkasseByBargeldtransaktion(bargeldtransaktion.Oid.Value) : null;
|
|
|
|
DateTime? signatureTimeSpanStart = serviceRecord?.Start ?? bargeldtransaktion?.Zahlungsdatum;
|
|
DateTime? signatureTimeSpanEnd = serviceRecord?.End ?? bargeldtransaktion?.Zahlungsdatum;
|
|
|
|
var employee = serviceRecord?.Employee;
|
|
var customer = serviceRecord?.Customer;
|
|
|
|
if((bargeldkasse?.ObjectTid == TableID.Customer) && bargeldkasse?.ObjectOid is object)
|
|
{
|
|
customer = DAOFactory.GenericDAO.LoadByID<Customer>(bargeldkasse.ObjectOid.Value);
|
|
}
|
|
|
|
var signatureHistoryEntry = new SignatureHistory
|
|
{
|
|
SignatureOid = signature.Oid,
|
|
CustomerOid = customer?.Oid,
|
|
EmployeeOid = employee?.Oid,
|
|
SignatureInsTs = signature.InsTs,
|
|
BargeldtransaktionsOid = signature.BargeldtransaktionsOid,
|
|
SignatureType = bargeldtransaktion is null ? SignatureTable.SingleSignature : SignatureTable.BargeldkasseneinzahlungsSignature,
|
|
TimeSpanStart = signatureTimeSpanStart,
|
|
TimeSpanEnd = signatureTimeSpanEnd,
|
|
SignatureEventType = signatureEventType
|
|
};
|
|
|
|
if(serviceRecord?.Oid is object)
|
|
{
|
|
signatureHistoryEntry.ServiceRecordOidList = new List<long> { serviceRecord.Oid.Value };
|
|
}
|
|
|
|
return signatureHistoryEntry;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ezeugt einen SignatureHistory-Eintrag für eine Monatsunterschrift
|
|
/// </summary>
|
|
/// <param name="signature">Die Monatsunterschrift zu der ein SignatureHistory-Eintrag erzeugt wird.</param>
|
|
/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
|
|
/// <returns>SignatureHistory-Einträge auf Basis der Monatsunterschrift</returns>
|
|
public SignatureHistory CreateMonthlySignatureHistoryEntry(ConfirmationReceiptSignature signature, SignatureEventType signatureEventType)
|
|
{
|
|
var serviceRecordOids = signature.ServiceRecords.Select(serviceRecord => serviceRecord.Oid.Value).ToList();
|
|
|
|
var a = signature.GetSignatureTimeSpan();
|
|
|
|
return new SignatureHistory
|
|
{
|
|
SignatureOid = signature.Oid,
|
|
SignatureInsTs = signature.InsTs,
|
|
SignatureType = signature.CustomerOid.HasValue ? SignatureTable.CustomerMonthlySignature : SignatureTable.EmployeeMonthlySignature,
|
|
ServiceRecordOidList = serviceRecordOids,
|
|
CustomerOid = signature.CustomerOid,
|
|
EmployeeOid = signature.CustomerOid is null ? signature.Employee?.Oid : null,
|
|
SignatureEventType = signatureEventType,
|
|
TimeSpanStart = a.StartDate,
|
|
TimeSpanEnd = a.EndDate
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erzeugt SignatureHistory-Einträge für alle unterschriebenen Bargeldtransaktionsunterschriften, falls man eine Bargeldkasse löscht.
|
|
/// </summary>
|
|
/// <param name="bargeldkasse">Die Bargeldkasse, die gelöscht wird.</param>
|
|
/// <returns>SignatureHistory-Einträge auf Basis der Bargeldkasse</returns>
|
|
public List<SignatureHistory> CreateSignatureHistoryEntryForBargeldkasse(Bargeldkasse bargeldkasse)
|
|
{
|
|
var signatureHistoryEntries = new List<SignatureHistory>();
|
|
|
|
var signatureOids2Transaktionsoid = new Dictionary<long, long>();
|
|
var bargeldtransaktionenMitUnterschrift = bargeldkasse.Bargeldtransaktionen.Where(t => t.SignatureOid.HasValue && t.Oid.HasValue).ToList();
|
|
|
|
foreach(var transaktion in bargeldtransaktionenMitUnterschrift)
|
|
{
|
|
signatureOids2Transaktionsoid.Add(transaktion.SignatureOid.Value, transaktion.Oid.Value);
|
|
}
|
|
|
|
var signatures = DAOFactory.GenericDAO.LoadByIDs<Signature>(signatureOids2Transaktionsoid.Keys);
|
|
|
|
signatures.DoForEach(sig =>
|
|
{
|
|
var transaktion = bargeldtransaktionenMitUnterschrift.FirstOrDefault(f => f.Oid.Equals(signatureOids2Transaktionsoid[sig.Oid.Value]));
|
|
|
|
if(transaktion is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var start = transaktion.Zahlungsdatum;
|
|
|
|
signatureHistoryEntries.Add(new SignatureHistory
|
|
{
|
|
BargeldtransaktionsOid = signatureOids2Transaktionsoid[sig.Oid.Value],
|
|
SignatureOid = sig.Oid,
|
|
CustomerOid = bargeldkasse.ObjectOid,
|
|
SignatureEventType = SignatureEventType.CascadingDelete,
|
|
SignatureInsTs = sig.InsTs,
|
|
SignatureType = SignatureTable.BargeldkasseneinzahlungsSignature,
|
|
TimeSpanStart = transaktion.Zahlungsdatum,
|
|
TimeSpanEnd = transaktion.Zahlungsdatum
|
|
});
|
|
});
|
|
|
|
return signatureHistoryEntries;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erzeugt einen SignatureHistory-Eintrag für die Bargeldtransaktionsunterschrift, die gelöscht oder geändert wird.
|
|
/// </summary>
|
|
/// <param name="transaktion">Bargeldtransaktion, die unterschrieben worden ist</param>
|
|
/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
|
|
/// <returns>SignatureHistory-Eintrag auf Basis des Bargeldtransaktion</returns>
|
|
public SignatureHistory CreateSignatureHistoryForBargeldtransaktion(Bargeldtransaktion transaktion, SignatureEventType signatureEventType)
|
|
{
|
|
var bargeldkasse = DAOFactory.SearchDAO.FindBargeldkasseByBargeldtransaktion(transaktion.Oid.Value);
|
|
var signature = DAOFactory.GenericDAO.LoadByID<Signature>(transaktion.SignatureOid.Value);
|
|
|
|
if(bargeldkasse is null || signature is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new SignatureHistory
|
|
{
|
|
SignatureEventType = signatureEventType,
|
|
BargeldtransaktionsOid = transaktion.Oid,
|
|
CustomerOid = bargeldkasse.ObjectOid,
|
|
SignatureInsTs = signature.InsTs,
|
|
SignatureOid = signature.Oid,
|
|
TimeSpanStart = transaktion.Zahlungsdatum,
|
|
TimeSpanEnd = transaktion.Zahlungsdatum,
|
|
SignatureType = SignatureTable.BargeldkasseneinzahlungsSignature
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erzeugt einen SignatureHistory-Eintrag für die Unterschrift, die kaskadierend beim Löschen eines ServiceRecords gelöscht wird.
|
|
/// </summary>
|
|
/// <param name="serviceRecord">Oid des ServiceRecords</param>
|
|
/// <returns>SignatureHistory-Eintrag auf Basis des ServiceRecords</returns>
|
|
public SignatureHistory CreateSignatureHistoryForServiceRecordUpdate(ServiceRecord serviceRecord, SignatureEventType signatureEventType)
|
|
{
|
|
var signature = DAOFactory.GenericDAO.LoadByID<Signature>(serviceRecord.SignatureOid.Value);
|
|
|
|
var signatureHistory = new SignatureHistory
|
|
{
|
|
CustomerOid = serviceRecord.CustomerOid,
|
|
EmployeeOid = serviceRecord.EmployeeOid,
|
|
SignatureEventType = signatureEventType,
|
|
TimeSpanStart = serviceRecord.Start,
|
|
TimeSpanEnd = serviceRecord.End,
|
|
SignatureOid = signature.Oid,
|
|
SignatureInsTs = signature.InsTs
|
|
};
|
|
|
|
return signatureHistory;
|
|
}
|
|
|
|
public ServiceRecord GetOldServiceRecordForSignatureHistoryEntry(long serviceRecordOid)
|
|
{
|
|
return CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), serviceRecordOid))
|
|
.UniqueResult<ServiceRecord>();
|
|
}
|
|
|
|
public bool CheckForExistingServiceRecordSignature(long serviceRecordOid)
|
|
{
|
|
var sql = $"SELECT SignatureOID FROM ServiceRecord sr WHERE sr.Oid = {serviceRecordOid}";
|
|
var query = Session.CreateSQLQuery(sql);
|
|
|
|
return query.UniqueResult<long?>() is object;
|
|
}
|
|
|
|
public Signature LoadJustDeletedSignature(long oid, bool isServiceRecord)
|
|
{
|
|
var tableName = isServiceRecord ? "servicerecord" : "bargeldtransaktion";
|
|
|
|
var sql = $"SELECT SignatureOid FROM {tableName} WHERE Oid = {oid} AND SignatureOid IS NOT NULL";
|
|
|
|
var query = Session.CreateSQLQuery(sql);
|
|
|
|
var signatureOid = query.UniqueResult<long?>();
|
|
|
|
return signatureOid.HasValue ? DAOFactory.GenericDAO.GetByID<Signature>(signatureOid.Value) : null;
|
|
}
|
|
|
|
public List<Bargeldtransaktion> LoadBargeldTransaktionenNonLazy(long bargeldkassenOid)
|
|
{
|
|
var sql = $"SELECT t.Oid FROM bargeldtransaktion t WHERE t.BargeldkassenOid = {bargeldkassenOid}";
|
|
|
|
var query = Session.CreateSQLQuery(sql);
|
|
|
|
var transactionOids = query.List<long>().ToArray();
|
|
|
|
var criteria = CreateCriteria<Bargeldtransaktion>()
|
|
.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), transactionOids));
|
|
|
|
var transactionsGottenByIds = new List<Bargeldtransaktion>();
|
|
|
|
foreach(var transactionOid in transactionOids)
|
|
{
|
|
transactionsGottenByIds.Add(DAOFactory.GenericDAO.GetByID<Bargeldtransaktion>(transactionOid));
|
|
}
|
|
|
|
var transactionsLoadedByIds = DAOFactory.GenericDAO.LoadByIDs<Bargeldtransaktion>(transactionOids);
|
|
|
|
var transactionsCriteriaResult = criteria.List<Bargeldtransaktion>().ToList();
|
|
|
|
return transactionsCriteriaResult;
|
|
}
|
|
}
|
|
}
|
|
|