659ec6b3eb
Die Abfrage nach der Ressourcenbelegung kommt nur ein mal und das Abbrechen des Speicherns hat keinen "kaputten" Reload zur Folge
Das Löschen eines Serientermins mit veränderten oder gelöschten Elementen führt zu keiner Exception mehr, da ich den Service-Aufruf auf synchron geändert habe.
Es gibt allerdings noch Bugs! -> Serientermin erstellen und ein Element davon ändern führt zu einer doppelten Abfrage, ausgelöst durch die Überlappungsprüfung, die eine Überlappung mit der Serie selbst feststellt!
3808 lines
182 KiB
C#
3808 lines
182 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 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 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 Oid FROM Person WHERE CONCAT_WS(' ', FirstName, LastName) LIKE '%{0}%'", pFullname));
|
|
var x = q.List<long>();
|
|
|
|
return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Employee>(x.First()) : 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 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 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_End, 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 (!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 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.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, 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 CreateCriteria<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)
|
|
{
|
|
return CreateCriteria<Login>()
|
|
.Add(Restrictions.Eq(Login.PropertyName_LoginName, loginName))
|
|
.AddOrder(Order.Desc("Oid"))
|
|
.SetMaxResults(10)
|
|
.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>();
|
|
}
|
|
|
|
public IList<ServiceRecord> FindServiceRecordsDetailsForLastDaysWithStartEndDate(long costbearer2SupportConcept, DateTime start, DateTime ende)
|
|
{
|
|
var c = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));
|
|
|
|
|
|
var max = ende.AddDays(1);
|
|
|
|
c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
|
|
.Add(Restrictions.Lt(ServiceRecord.PropertyName_End, max.Date));
|
|
|
|
|
|
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>();
|
|
}
|
|
|
|
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 CreateCriteriaIsActive<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 IEnumerable<AbsenceTime> FindAbsenceTimes(DateTime startDate, DateTime endDate)
|
|
{
|
|
var criteria = CreateCriteriaIsActive<AbsenceTime>()
|
|
.Add(
|
|
Restrictions.Or(
|
|
CreateBetweenDateTimesCriterion(startDate, endDate, nameof(AbsenceTime.Start), nameof(AbsenceTime.End)),
|
|
Restrictions.And(
|
|
Restrictions.And(
|
|
Restrictions.Ge(AbsenceTime.PropertyName_Start, startDate),
|
|
Restrictions.Le(AbsenceTime.PropertyName_Start, endDate)),
|
|
Restrictions.IsNull(AbsenceTime.PropertyName_End)
|
|
)
|
|
)
|
|
);
|
|
|
|
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<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<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)))
|
|
.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))
|
|
.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;
|
|
}
|
|
|
|
// TODO: Ändert man einen Serientermin, wird ZWEIMAL eine Warnung angezeigt, dass sich der Termin mit einem anderen Termin überschneidet! Dieser Termin ist die Serie selbst!
|
|
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)
|
|
{
|
|
var isRecurrenceException = appointmentOid == null;
|
|
|
|
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 == 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 => Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
var changedOccurences = schedulerAppointments.Where(app => app.Type == 3).Select(app => Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
|
|
|
|
var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));
|
|
|
|
var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().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);
|
|
pattern.RecurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
pattern.Start = pattern.RecurrenceInfo.Start;
|
|
pattern.End = 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 == null || appointment.StartDate == 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.
|
|
if(!start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration)) ||
|
|
changedOccurences.Any(changedOccurence => changedOccurence.PatternId.Equals(patternId) && changedOccurence.Index == index) ||
|
|
deletedOccurences.Any(deletedOccurence => deletedOccurence.PatternId.Equals(patternId) && deletedOccurence.Index == index) ||
|
|
index == occurrenceIndex && guidParsingSuccessful && 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;
|
|
// Indices und Ids der RecurrenceInfo vergleichen. Stimmen sie überein, dann wird das generiert Serienelement ignoriert.
|
|
if(occurrence.RecurrenceInfo?.Id != null)
|
|
{
|
|
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 oidList = new List<long>();
|
|
|
|
schedulerAppointments = schedulerAppointments.Where(appointment => appointment.Type != 4).ToList();
|
|
|
|
foreach (var appointment in schedulerAppointments)
|
|
{
|
|
if(shouldIgnoreAppointment)
|
|
{
|
|
if(!ShouldDoAppointmentOverlappingCheck(appointment, recurrenceGuid.Value))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
oidList.AddRange(appointment.EmployeeList.Select(rel => rel.ParticipationAnswer != ParticipationAnswer.Absage && rel.Employee.Oid != null ? rel.Employee.Oid.Value : 0));
|
|
}
|
|
|
|
var hasOverlappingEmployeeAppointments = oidList.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)
|
|
{
|
|
var recId = appointment.GetRecurrenceIdAndIndex(out var recIndex);
|
|
|
|
if(appointment.RecurrenceInfo != null && recId != null)
|
|
{
|
|
if(recId.Equals(recurrenceId))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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<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)
|
|
{
|
|
var result = new List<long>();
|
|
var appointments = GetAllActiveAppointmentsForEmployeeInInterval2(pStartTime, pEndTime, pEmployeeOids);
|
|
var gefilterteTermine = appointments.Where(w => 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));
|
|
|
|
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 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(CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum)),
|
|
Restrictions.And(Restrictions.Le(CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum))))
|
|
.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 = CreateCriteria<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>();
|
|
}
|
|
|
|
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>();
|
|
}
|
|
|
|
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 notEmployee2SchedCrit = Subqueries.PropertyNotex(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);
|
|
|
|
//and not exists(
|
|
// SELECT
|
|
//this_0_.Oid as y0_
|
|
//FROM
|
|
// Employee2NewSchApp this_0_
|
|
// WHERE
|
|
//this_0_.NewSchAppOid = this_.Oid
|
|
// )
|
|
var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
|
|
.SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid))
|
|
.Add(Restrictions.EqProperty("e2s2." + Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, "sa.Oid"));
|
|
//.Add(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment + ".Oid", mainCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_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);
|
|
}
|
|
// AND {SchedulerAppointment.PropertyName_RecurrenceInfo} IS NOT NULL AND {SchedulerAppointment.PropertyName_RecurrenceInfo} NOT LIKE '%Index%'
|
|
var listOfCriterias = new List<ICriterion>
|
|
{
|
|
employeeCriterion,
|
|
customerCriterion,
|
|
resourceCriterion
|
|
};
|
|
|
|
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>();
|
|
|
|
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);
|
|
|
|
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)
|
|
{
|
|
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(!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<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)
|
|
{
|
|
var c = CreateCriteriaIsActive<SchedulerAppointment>()
|
|
.Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true));
|
|
|
|
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<SchedulerAppointment> GetTestAppointments()
|
|
{
|
|
var c = CreateCriteria<SchedulerAppointment>();
|
|
|
|
c.Add(Restrictions.Eq(nameof(BeWoEntityBase.Notice), 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>
|
|
/// <returns>test</returns>
|
|
public List<Resource> CheckAvailabilityOfResources(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid)
|
|
{
|
|
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 {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);
|
|
|
|
return c.List<Resource>().ToList();
|
|
}
|
|
|
|
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)));
|
|
|
|
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);
|
|
|
|
lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public Dictionary<long, List<ServiceRecord>> FindListOfCustomerServiceRecordsForKilometerauswertung(List<long> customerOids, DateTimeSpan span)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.CustomerOid), customerOids))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)));
|
|
|
|
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);
|
|
|
|
lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));
|
|
|
|
var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
var result = new Dictionary<long, List<ServiceRecord>>();
|
|
|
|
foreach(var serviceRecord in allServiceRecords)
|
|
{
|
|
result.AddOrUpdateValueInDictionary(serviceRecord.CustomerOid.Value, new List<ServiceRecord> {serviceRecord});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public bool CheckForAnyServiceRecordsWithDistanceValues(List<long> customerOids, DateTimeSpan span)
|
|
{
|
|
return FindListOfCustomerServiceRecordsForKilometerauswertung(customerOids, 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;
|
|
}
|
|
|
|
public IList<ConfirmationReceiptSignature> GetConfirmationReceiptSignaturesByEmployee(long employeeOid, DateTimeSpan timeSpan)
|
|
{
|
|
var liste = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), 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 = CreateCriteria<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)));
|
|
|
|
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);
|
|
|
|
lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));
|
|
|
|
return lCriteria.List<ServiceRecord>();
|
|
}
|
|
|
|
public Dictionary<long, List<ServiceRecord>> FindListOfEmployeeServiceRecordsForKilometerauswertung(List<long> employeeOids, DateTimeSpan span)
|
|
{
|
|
var lCriteria = CreateCriteria<ServiceRecord>()
|
|
.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids))
|
|
.Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)));
|
|
|
|
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);
|
|
|
|
lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));
|
|
|
|
var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();
|
|
|
|
var result = new Dictionary<long, List<ServiceRecord>>();
|
|
|
|
foreach(var serviceRecord in allServiceRecords)
|
|
{
|
|
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.CustomerView_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 bool HasEmployeeSignatureForCustomerInTimeSpan(long customerOid, DateTimeSpan timeSpan)
|
|
{
|
|
var start = timeSpan.StartDate.GetFirstOfMonth();
|
|
var end = timeSpan.EndDate.GetLastOfMonth();
|
|
|
|
var timeSpanCriterion = CreateBetweenDateTimesCriterion(start, end, $"serviceRecord.{nameof(ServiceRecord.Start)}", $"serviceRecord.{nameof(ServiceRecord.End)}");
|
|
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.Eq($"serviceRecord.{nameof(ServiceRecord.CustomerOid)}", customerOid))
|
|
.Add(timeSpanCriterion);
|
|
|
|
var hasAny = criteria.List<ConfirmationReceiptSignature>().Any();
|
|
|
|
return hasAny;
|
|
}
|
|
|
|
public bool HasEmployeeSignaturesForServiceRecord(long serviceRecordOid)
|
|
{
|
|
return GetConfirmationReceiptSignaturesByServiceRecord(serviceRecordOid).Any();
|
|
}
|
|
|
|
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 bool HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), 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)
|
|
{
|
|
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>()
|
|
.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;
|
|
}
|
|
|
|
public IEnumerable<ConfirmationReceiptSignature> FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
|
|
{
|
|
var criteria = CreateCriteria<ConfirmationReceiptSignature>()
|
|
.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
|
|
.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
|
|
.Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));
|
|
|
|
return criteria.List<ConfirmationReceiptSignature>();
|
|
}
|
|
}
|
|
}
|