5992 lines
290 KiB
C#
5992 lines
290 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
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 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<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)
|
|
{
|
|
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));
|
|
}
|
|
|
|
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);
|
|
|
|
teams.DoForEach(team => { team.MemberList.DoForEach(member => result.AddRangeIfElementsNotIn(member.Employee2CustomerList.Select(employee2Customer => employee2Customer.Customer))); });
|
|
}
|
|
|
|
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 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);
|
|
|
|
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);
|
|
}
|
|
|
|
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)
|
|
{
|
|
criteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minStart));
|
|
rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minStart));
|
|
}
|
|
|
|
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.HasValue)
|
|
{
|
|
var minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
|
|
criteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
|
|
rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
|
|
}
|
|
|
|
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(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
var rowCountCirteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
var max = ende.Date.AddDays(1);
|
|
|
|
criteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, max.Date));
|
|
|
|
rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, max.Date));
|
|
|
|
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(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)
|
|
.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.Lt(ServiceRecord.PropertyName_End, max.Date));
|
|
|
|
rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(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<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();
|
|
}
|
|
}
|
|
}
|