Lyndon Jetten
58b361498f
ServiceRecord-Fremdschlüssel zu NewSchedulerAppointment-Tabelle hinzugefügt. Funktionalität ist noch nicht implementiert. MoK: Ziele/Maßnahmen verbessert; Suche funktioniert jetzt richtig Mehrfachbuchung implementiert Kalender: Termine sind jetzt löschbar, wenn Recht zu bearbeiten vorhanden ist. Unterscheidung zwischen Mitarbeiter-, Klienten-, und Ressourcenauswahl bei Ansicht und Formular
978 lines
39 KiB
C#
978 lines
39 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Web.Mvc;
|
|
|
|
using BeWoPlanerMobil.Models;
|
|
using BeWoPlanerMobil.Service;
|
|
using BeWoPlanerMobil.Util;
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using DevExpress.XtraScheduler;
|
|
using DevExpress.XtraScheduler.Compatibility;
|
|
using Newtonsoft.Json;
|
|
using static BeWoPlanerMobil.Util.MobileUtils;
|
|
using RecurrenceInformation = BS.Shared.Core.RecurrenceInformation;
|
|
|
|
namespace BeWoPlanerMobil.Controllers
|
|
{
|
|
public class SchedulerController : AbstractBaseController
|
|
{
|
|
private SchedulerModel _Model;
|
|
public SchedulerModel Model
|
|
{
|
|
get
|
|
{
|
|
if (!MobileSessionFacade.IsUserLoggedIn())
|
|
{
|
|
Logout();
|
|
return null;
|
|
}
|
|
|
|
if (((SchedulerModel) Session[ModelSessionConstants.SchedulerModelKey])?.Employee is null)
|
|
{
|
|
_Model = new SchedulerModel { Employee = MobileSessionFacade.LoggedInEmployee };
|
|
Session[ModelSessionConstants.SchedulerModelKey] = _Model;
|
|
}
|
|
else
|
|
{
|
|
_Model = (SchedulerModel) Session[ModelSessionConstants.SchedulerModelKey];
|
|
}
|
|
|
|
return _Model;
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult Scheduler()
|
|
{
|
|
if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeScheduler)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
if(AbstractModel.HasRightToInsertRessourceAppointments)
|
|
{
|
|
var allResources = KalenderService.GetAllResources().ToList();
|
|
|
|
var categories2Resources = new Dictionary<ValueListEntryDC, List<ResourceDC>>();
|
|
|
|
foreach(var category in allResources.Select(resource => resource.ResourceCategory))
|
|
{
|
|
categories2Resources.AddOrUpdateValueInDictionary(category, allResources.Where(resource => resource.ResourceCategory.Equals(category)).ToList());
|
|
}
|
|
|
|
Model.ResourceCategories2Resources = categories2Resources;
|
|
}
|
|
|
|
if(Model?.Employee?.EmployeeOid.HasValue ?? false)
|
|
{
|
|
var compactEmployee = EmployeeService.GetActiveCompactEmployeeWithOid(Model.Employee.EmployeeOid.Value);
|
|
|
|
Model.MyTeamEmployees = EmployeeService.GetAllTeamMember(compactEmployee);
|
|
}
|
|
else if(!(Model is null))
|
|
{
|
|
Model.MyTeamEmployees = new List<CompactEmployeeDC>();
|
|
}
|
|
|
|
if(AbstractModel.HasRightToViewTeams && (Model?.Employee?.EmployeeOid.HasValue ?? false))
|
|
{
|
|
Model.MyTeams = EmployeeService.GetAllActiveCompactTeamsForEmployee(Model.Employee.EmployeeOid.Value);
|
|
}
|
|
|
|
LoadAppointmentsForDate();
|
|
|
|
return View(Model);
|
|
}
|
|
|
|
private void LoadAppointmentsForDate()
|
|
{
|
|
if(Model?.Employee.EmployeeOid is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var date = Model.SelectedDate;
|
|
var monday = date.GetInSameCalendarWeek(DayOfWeek.Monday);
|
|
var sunday = monday.Date.AddDays(6);
|
|
|
|
var start = date;
|
|
var end = date.AddDays(1);
|
|
|
|
if(Model.SelectedSchedulerView == "5")
|
|
{
|
|
start = monday;
|
|
end = monday.AddDays(4);
|
|
}
|
|
else if(Model.SelectedSchedulerView == "7")
|
|
{
|
|
start = monday;
|
|
end = sunday;
|
|
}
|
|
|
|
var selectedCustomers = Model.SelectedCustomersForFiltering?.Select(s => s.CustomerOid).ToList() ?? new List<long>();
|
|
var selectedEmployees = Model.SelectedEmployeesForFiltering?.Select(s => s.EmployeeOid).ToList() ?? new List<long>();
|
|
var selectedResources = Model.SelectedResourcesForFiltering?.Where(w => w.ResourceOid.HasValue).Select(s => s.ResourceOid.Value).ToList() ?? new List<long>();
|
|
|
|
var appointments = KalenderService.LoadFilteredAppointmentsMitAufgaben(AbstractModel.HasRightToViewEmployeeAppointments, Model.Employee.EmployeeOid.Value, start.Date, end, selectedEmployees, selectedCustomers, selectedResources, false, false, false, false, true, true).ToList();
|
|
|
|
var tasks = appointments.Where(w => w.IsTask && w.CompletedDate is null).ToList();
|
|
|
|
// Nur eigene Kliententermine ansehen
|
|
if(!AbstractModel.HasRightToViewCustomerAppointments)
|
|
{
|
|
appointments = appointments.Where(a => a.CustomerList.All(c => MobileSessionFacade.LoggedInEmployee.RelatedCustomers.Any(rc => rc.Customer.Equals(c)))).ToList();
|
|
}
|
|
|
|
if(!AbstractModel.HasRightToViewAllResourceAppointments)
|
|
{
|
|
appointments = appointments.Where(a => a.ResourceList.Count == 0).ToList();
|
|
}
|
|
|
|
if(!AbstractModel.IsAllowedToSeeCustomers)
|
|
{
|
|
appointments = appointments.Where(a => a.CustomerList.Count == 0).ToList();
|
|
}
|
|
|
|
var holySweetFlyingFuck = appointments.Where(w =>
|
|
w.IsTask == false && // Aufgaben ausschließen
|
|
w.StartDate.HasValue && w.EndDate.HasValue && // Datumsangaben haben einen Wert
|
|
|
|
(date.InBetween(w.StartDate.Value, w.EndDate.Value, false) || date.CompareShortDates(w.StartDate.Value))
|
|
// Einzeltermine oder Ausnahmen und gelöschte Ausnahmen
|
|
&& (w.RecurrenceInfo is null || w.RecurrenceInfo != null && (w.Type == 3 || w.Type == 4))
|
|
|
|
).ToList();
|
|
|
|
var deletedOccurrences = holySweetFlyingFuck.Where(w => w.Type == 4).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
var changedOccurrences = holySweetFlyingFuck.Where(w => w.Type == 3).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
|
|
holySweetFlyingFuck = holySweetFlyingFuck.Where(w => w.Type != 4).ToList();
|
|
|
|
holySweetFlyingFuck.AddRangeIfElementsNotIn(CalculateRecurrences(appointments, start, end, changedOccurrences, deletedOccurrences));
|
|
|
|
holySweetFlyingFuck.AddRange(tasks);
|
|
|
|
// Wenn es ein ganztägiger Termin ist, eine Sekunde abziehen und beim Speichern wieder draufaddieren?
|
|
foreach(var app in holySweetFlyingFuck.Where(a => a.AllDay))
|
|
{
|
|
app.EndDate = app.EndDate.Value.AddMinutes(-1);
|
|
}
|
|
|
|
Model.Appointments = holySweetFlyingFuck.Where(w => w.IsTask == Model.ShouldLoadTasks).OrderBy(appointment => appointment.StartDate).ToList();
|
|
|
|
Model.WeekViewObject = new WeekViewObject(Model.Appointments, Model.SelectedDate.GetInSameCalendarWeek(DayOfWeek.Monday));
|
|
|
|
if(AbstractModel.HasRightToViewCustomerSelectionInScheduler)
|
|
{
|
|
Model.AllCustomers = EmployeeService.GetActiveCompactCustomersForEmployee(Model.Employee.EmployeeOid).OrderBy(o => o.DetailDescription).ToList();
|
|
}
|
|
|
|
if(AbstractModel.HasRightToViewEmployeeAppointments)
|
|
{
|
|
Model.AllEmployees = EmployeeService.GetActiveCompactEmployeesForEmployee(Model.Employee.EmployeeOid.Value).OrderBy(o => o.DetailDescription).ToList();
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<SchedulerAppointmentDC> CalculateRecurrences(IEnumerable<SchedulerAppointmentDC> appointments, DateTime start, DateTime end, IReadOnlyCollection<RecurrenceInformation> changedOccurrences, IReadOnlyCollection<RecurrenceInformation> deletedOccurrences)
|
|
{
|
|
var result = new List<SchedulerAppointmentDC>();
|
|
|
|
var interval = new TimeInterval(start, end);
|
|
|
|
foreach (var appointment in appointments.Where(app => app.RecurrenceInfo != null && app.Type == 1))
|
|
{
|
|
var recurrenceInfo = new RecurrenceInfo();
|
|
recurrenceInfo.FromXml(appointment.RecurrenceInfo);
|
|
var occurrenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);
|
|
|
|
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();
|
|
|
|
var occurrences = occurrenceCalculator.CalcOccurrences(interval, pattern);
|
|
|
|
if(occurrences.Count > 0)
|
|
{
|
|
foreach(var app in occurrences.GetAppointments(interval))
|
|
{
|
|
var index = app.RecurrenceIndex;
|
|
|
|
var duration = (appointment.EndDate.Value - appointment.StartDate.Value).TotalMinutes;
|
|
|
|
var isOutOfInterval = app.Start.GetShortDateTime().AreInBetweenDates(app.Start.AddMinutes(duration), start, end) == false;
|
|
var isChangedOccurrence = changedOccurrences.Any(a => a.PatternId.Equals(patternId) && a.Index == index);
|
|
var isDeletedOccurrence = deletedOccurrences.Any(a => a.PatternId.Equals(patternId) && a.Index == index);
|
|
|
|
if(isOutOfInterval || isChangedOccurrence || isDeletedOccurrence)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var recurringAppointment = new SchedulerAppointmentDC
|
|
{
|
|
AllDay = appointment.AllDay,
|
|
CustomerList = appointment.CustomerList,
|
|
Description = appointment.Description,
|
|
EmployeeList = appointment.EmployeeList,
|
|
EndDate = app.Start.AddMinutes(duration),
|
|
FormerBookingSequenceOid = appointment.FormerBookingSequenceOid,
|
|
IsPrivate = appointment.IsPrivate,
|
|
LabelKey = appointment.LabelKey,
|
|
Location = appointment.Location,
|
|
Originator = appointment.Originator,
|
|
RecurrenceInfo = app.RecurrenceInfo.ToXml(),
|
|
ReminderInfo = appointment.ReminderInfo,
|
|
ResourceList = appointment.ResourceList,
|
|
StartDate = app.Start,
|
|
Subject = appointment.Subject ?? "",
|
|
Type = appointment.Type
|
|
};
|
|
|
|
result.AddIfNotIn(recurringAppointment);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Es wird bei ganztägigen Serienterminen eine Minute abgezogen, damit die nicht als zweitägig angezeigt werden. Bearbeiten kann man Serientermin im MoK noch nicht.
|
|
foreach(var app in result.Where(w => w.AllDay && w.EndDate.HasValue))
|
|
{
|
|
app.EndDate = app.EndDate.Value.AddMinutes(-1);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult InsertOrUpdateAppointment(FormCollection formCollection)
|
|
{
|
|
try
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
}
|
|
|
|
var rawStartDate = formCollection[FormCollectionConstants.AppointmentStartDateKey];
|
|
var rawEndDate = formCollection[FormCollectionConstants.AppointmentEndDateKey];
|
|
var rawStartTime = formCollection[FormCollectionConstants.AppointmentStartTimeKey];
|
|
var rawEndTime = formCollection[FormCollectionConstants.AppointmentEndTimeKey];
|
|
var subject = formCollection[FormCollectionConstants.AppointmentSubjectKey];
|
|
var location = formCollection[FormCollectionConstants.AppointmentLocationKey];
|
|
var notice = formCollection[FormCollectionConstants.AppointmentNoticeKey];
|
|
|
|
var isPrivate = formCollection[FormCollectionConstants.AppointmentIsPrivate] == "true,false";
|
|
var allDay = formCollection[FormCollectionConstants.AppointmentIsAllDay] == "true,false";
|
|
|
|
var isSuccessfulStartTime = DateTime.TryParseExact(rawStartTime, "HH:mm", null, DateTimeStyles.None, out var startTime);
|
|
var isSuccessfulEndTime = DateTime.TryParseExact(rawEndTime, "HH:mm", null, DateTimeStyles.None, out var endTime);
|
|
|
|
if(rawStartTime is null)
|
|
{
|
|
rawStartTime = "00:00";
|
|
}
|
|
|
|
if (rawEndTime is null)
|
|
{
|
|
rawEndTime = "00:00";
|
|
}
|
|
|
|
var startAndEnd = ConvertStringDatesToDateTimes($"{rawStartDate} {rawStartTime}", $"{rawEndDate} {rawEndTime}");
|
|
|
|
var startDate = startAndEnd.StartDate;
|
|
var endDate = startAndEnd.EndDate;
|
|
|
|
if (!allDay && isSuccessfulStartTime && isSuccessfulEndTime || allDay)
|
|
{
|
|
startDate = startDate.MergeDatesByDate(startTime);
|
|
endDate = endDate.MergeDatesByDate(endTime);
|
|
|
|
var appointmentToInsert = Model.SelectedAppointment ?? new SchedulerAppointmentDC();
|
|
|
|
var isNew = !appointmentToInsert.SchedulerAppointmentOid.HasValue;
|
|
|
|
var appointmentEmployeeList = new List<Employee2SchedulerAppointmentDC>();
|
|
if(Model.SelectedEmployees?.Any() ?? false)
|
|
{
|
|
foreach(var employee in Model.SelectedEmployees)
|
|
{
|
|
var employee2Appointment = new Employee2SchedulerAppointmentDC
|
|
{
|
|
Employee = employee,
|
|
};
|
|
|
|
appointmentEmployeeList.Add(employee2Appointment);
|
|
}
|
|
}
|
|
|
|
appointmentToInsert.EmployeeList = appointmentEmployeeList;
|
|
appointmentToInsert.CustomerList = Model.SelectedCustomers;
|
|
appointmentToInsert.ResourceList = Model.SelectedResources ?? new List<ResourceDC>();
|
|
appointmentToInsert.SupportConceptList = isNew ? new List<CompactSupportConceptDC>() : appointmentToInsert.SupportConceptList;
|
|
appointmentToInsert.EndDate = endDate;
|
|
appointmentToInsert.StartDate = startDate;
|
|
appointmentToInsert.Subject = subject;
|
|
appointmentToInsert.Description = notice;
|
|
appointmentToInsert.Originator = MobileSessionFacade.LoggedInCompactEmployee;
|
|
appointmentToInsert.Location = location;
|
|
appointmentToInsert.ActivationType = ActivationTypeId.Active;
|
|
appointmentToInsert.IsPrivate = isPrivate;
|
|
appointmentToInsert.AllDay = allDay;
|
|
|
|
// Eine Minute addieren, wenn die Uhrzeit eines ganztägigen Termins nicht exakt 00:00 ist.
|
|
if(allDay && endDate.Hour == 23 && endDate.Minute == 59)
|
|
{
|
|
appointmentToInsert.EndDate = endDate.AddMinutes(1);
|
|
}
|
|
|
|
// ToDo: Rechte beachten!
|
|
if(appointmentToInsert.CanBeEdited)
|
|
{
|
|
if(!isNew)
|
|
{
|
|
KalenderService.UpdateSchedulerAppointments(new List<SchedulerAppointmentDC> {appointmentToInsert});
|
|
}
|
|
else
|
|
{
|
|
KalenderService.InsertSchedulerAppointments(new List<SchedulerAppointmentDC> {appointmentToInsert});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Log.Error(exception.Message, exception);
|
|
}
|
|
finally
|
|
{
|
|
if (Model != null)
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
Model.SelectedResources?.Clear();
|
|
}
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult NavigateToPreviousDate()
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
}
|
|
|
|
Model.SelectedDate = Model.SelectedDate.AddDays(-1);
|
|
|
|
if(Model != null)
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
//Model.SelectedResources.Clear();
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult NavigateToNextDate()
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
}
|
|
|
|
Model.SelectedDate = Model.SelectedDate.AddDays(1);
|
|
|
|
if(!(Model is null))
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
//Model.SelectedResources.Clear();
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SelectSchedulerDate(FormCollection formCollection) {
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
}
|
|
|
|
var rawSchedulerDate = formCollection[FormCollectionConstants.AppointmentSchedulerDateKey];
|
|
|
|
var schedulerDate = DateTime.ParseExact(rawSchedulerDate, "dd.MM.yyyy", null);
|
|
|
|
Model.SelectedDate = schedulerDate;
|
|
|
|
if(Model != null)
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
Model.SelectedResources.Clear();
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SelectAppointmentToEdit(FormCollection formCollection)
|
|
{
|
|
var rawOid = formCollection[FormCollectionConstants.AppointmentSchedulerOidHolderKey];
|
|
|
|
var isSuccessful = long.TryParse(rawOid, out var appointmentOid);
|
|
|
|
if (isSuccessful)
|
|
{
|
|
Model.SelectedAppointment = Model.Appointments.FirstOrDefault(app => app.SchedulerAppointmentOid.HasValue && app.SchedulerAppointmentOid.Value == appointmentOid);
|
|
|
|
if(Model.SelectedAppointment != null)
|
|
{
|
|
Model.IsAllDay = Model.SelectedAppointment.AllDay;
|
|
Model.IsPrivate = Model.SelectedAppointment.IsPrivate;
|
|
Model.SelectedResources = Model.SelectedAppointment?.ResourceList ?? new List<ResourceDC>();
|
|
Model.SelectedEmployees = Model.SelectedAppointment?.EmployeeList.Select(e2a => e2a.Employee).ToList() ?? new List<CompactEmployeeDC>();
|
|
Model.SelectedCustomers = Model.SelectedAppointment?.CustomerList ?? new List<CompactCustomerDC>();
|
|
}
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
public JsonResult ResetSelectedAppointment()
|
|
{
|
|
if (Model != null)
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
Model.SelectedResources.Clear();
|
|
Model.IsAllDay = false;
|
|
Model.IsPrivate = false;
|
|
}
|
|
|
|
return Json(null, JsonRequestBehavior.AllowGet);
|
|
}
|
|
|
|
[Authorize]
|
|
public JsonResult CheckForOverlappingAppointments(string startDateRaw, string endDateRaw, string startTimeRaw, string endTimeRaw)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return null;
|
|
}
|
|
|
|
var isOverlapping = false;
|
|
var oid = Model.SelectedAppointment?.SchedulerAppointmentOid;
|
|
|
|
var isSuccessfulStartDate = DateTime.TryParseExact(startDateRaw, "dd.MM.yyyy", null, DateTimeStyles.None, out var startDate);
|
|
var isSuccessfulStartTime = DateTime.TryParseExact(startTimeRaw, "HH:mm", null, DateTimeStyles.None, out var startTime);
|
|
var isSuccessfulEndDate = DateTime.TryParseExact(endDateRaw, "dd.MM.yyyy", null, DateTimeStyles.None, out var endDate);
|
|
var isSuccessfulEndTime = DateTime.TryParseExact(endTimeRaw, "HH:mm", null, DateTimeStyles.None, out var endTime);
|
|
|
|
if (isSuccessfulStartDate && isSuccessfulStartTime && isSuccessfulEndDate && isSuccessfulEndTime)
|
|
{
|
|
startDate = startDate.MergeDatesByDate(startTime);
|
|
endDate = endDate.MergeDatesByDate(endTime);
|
|
|
|
var customerOidList = Model.SelectedAppointment?.CustomerList?.Select(customer => customer.CustomerOid).ToList() ?? new List<long>();
|
|
var employeeOidList = Model.SelectedAppointment?.EmployeeList?.Select(employee2Appointment => employee2Appointment.Employee.EmployeeOid).ToList() ?? new List<long>();
|
|
var resourceOidList = Model.SelectedResources.Where(resource => resource.ResourceOid.HasValue).Select(resource => resource.ResourceOid.Value).ToList() ?? new List<long>();
|
|
|
|
var originator = Model.SelectedAppointment?.Originator ?? MobileSessionFacade.LoggedInCompactEmployee;
|
|
|
|
var recurrenceId = Model.SelectedAppointment?.RecurrenceId ?? string.Empty;
|
|
var recurrenceIndex = Model.SelectedAppointment?.RecurrenceIndex ?? 0;
|
|
|
|
isOverlapping = KalenderService.OverlappingAppointmentsExist(startDate, endDate, employeeOidList, customerOidList, resourceOidList, originator.EmployeeOid, oid, recurrenceId, recurrenceIndex);
|
|
|
|
// TODO: Serientermine überprüfen
|
|
if(Model.Appointments != null)
|
|
{
|
|
foreach(var appointment in Model.Appointments.Where(app => app.SchedulerAppointmentOid is null && app.IsTask == false))
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return Json(isOverlapping, JsonRequestBehavior.AllowGet);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectResourcesForAppointment(string resourceOids)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(resourceOids);
|
|
|
|
var list = new List<ResourceDC>();
|
|
|
|
Model.ResourceCategories2Resources.Values.DoForEach(l => l.DoForEach(s => list.AddIfNotIn(s)));
|
|
|
|
Model.SelectedResources = list.Where(resource => resource.ResourceOid.HasValue && oidList.Contains(resource.ResourceOid.Value)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedResources);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectEmployeesForAppointment(string oidString)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedEmployees = Model.AllEmployees.Where(employee => oidList.Contains(employee.EmployeeOid)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedEmployees.OrderBy(o => o.DetailDescription));
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectCustomersForAppointment(string oidString)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedCustomers = Model.AllCustomers.Where(customer => oidList.Contains(customer.CustomerOid)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedCustomers.OrderBy(o => o.LastNameFirstName));
|
|
}
|
|
|
|
[Authorize]
|
|
public string CheckResourcesAvailability(string start, string end, string resourceOids)
|
|
{
|
|
if(!AbstractModel.HasRightToInsertRessourceAppointments)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
if(!string.IsNullOrWhiteSpace(start) && !string.IsNullOrWhiteSpace(end) && !string.IsNullOrWhiteSpace(resourceOids) && Model != null)
|
|
{
|
|
var oidList = ConvertOidStringToList(resourceOids);
|
|
|
|
foreach(var oid in oidList)
|
|
{
|
|
if(!Model.ResourceCategories2Resources.Any(a => a.Value.All(b => b.ResourceOid != oid)))
|
|
{
|
|
return JsonConvert.SerializeObject(new List<ResourceDC>());
|
|
}
|
|
}
|
|
|
|
var dateTimes = ConvertStringDatesToDateTimes(start, end);
|
|
|
|
var unavailableResources = KalenderService.CheckResourceAvailability(dateTimes.StartDate, dateTimes.EndDate, oidList, Model.SelectedAppointment?.SchedulerAppointmentOid);
|
|
|
|
return JsonConvert.SerializeObject(unavailableResources);
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[Authorize]
|
|
public string HasSelectedAppointment()
|
|
{
|
|
return JsonConvert.SerializeObject(Model?.SelectedAppointment != null);
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult ChangeSchedulerView(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var selectedSchedulerView = formCollection["SelectedSchedulerView"];
|
|
|
|
Model.SelectedSchedulerView = selectedSchedulerView;
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult FindFreeIntervals(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var d = formCollection["Duration"];
|
|
var s = formCollection["IntervalStart"].Substring(0, 10);
|
|
var st = formCollection["IntervalStartTime"];
|
|
var e = formCollection["IntervalEnd"].Substring(0, 10);
|
|
var et = formCollection["IntervalEndTime"];
|
|
|
|
if (int.TryParse(d, out var duration) && DateTime.TryParse($"{s} {st}", out var start) && DateTime.TryParse($"{e} {et}", out var end) && Model.Employee.EmployeeOid.HasValue)
|
|
{
|
|
var customerOids = Model.SelectedCustomersForIntervalFinder.Select(c => c.CustomerOid).ToList();
|
|
var employeeOids = Model.SelectedEmployeesForIntervalFinder.Select(m => m.EmployeeOid).ToList();
|
|
var resourceOids = Model.SelectedResourcesForIntervalFinder.Where(w => w.ResourceOid.HasValue).Select(r => r.ResourceOid.Value).ToList();
|
|
|
|
Model.FreeIntervals = KalenderService.FindAppointmentsInRange(duration, start, end, resourceOids, customerOids, employeeOids, Model.Employee.EmployeeOid.Value);
|
|
|
|
Model.IntervalStartDate = start;
|
|
Model.IntervalEndDate = end;
|
|
Model.IntervalDuration = duration;
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectEmployeesForIntervalFinder(string oidString)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var employeeOids = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedEmployeesForIntervalFinder = Model.AllEmployees.Where(employee => employeeOids.Contains(employee.EmployeeOid)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedEmployeesForIntervalFinder.OrderBy(o => o.DetailDescription));
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectCustomersForIntervalFinder(string oidString)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var customerOids = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedCustomersForIntervalFinder = Model.AllCustomers.Where(customer => customerOids.Contains(customer.CustomerOid)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedCustomersForIntervalFinder.OrderBy(o => o.LastNameFirstName));
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectResourcesForIntervalFinder(string resourceOids)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var resourceOidList = ConvertOidStringToList(resourceOids);
|
|
|
|
var list = new List<ResourceDC>();
|
|
|
|
Model.ResourceCategories2Resources.Values.DoForEach(l => l.DoForEach(s => list.AddIfNotIn(s)));
|
|
|
|
Model.SelectedResourcesForIntervalFinder = list.Where(resource => resource.ResourceOid.HasValue && resourceOidList.Contains(resource.ResourceOid.Value)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedResourcesForIntervalFinder);
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SetIsInIntervalFinderMode(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var newValue = !Model.IsInIntervalFinderMode;
|
|
|
|
Model.IsInIntervalFinderMode = newValue;
|
|
|
|
if(!newValue)
|
|
{
|
|
Model.SelectedEmployeesForIntervalFinder.Clear();
|
|
Model.SelectedCustomersForIntervalFinder.Clear();
|
|
Model.SelectedResourcesForIntervalFinder.Clear();
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SelectIntervalForForm(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var startStr = formCollection["startDate"];
|
|
var endStr = formCollection["endDate"];
|
|
|
|
if(DateTime.TryParse(startStr, out var startDate) && DateTime.TryParse(endStr, out var endDate))
|
|
{
|
|
Model.IsInIntervalFinderMode = false;
|
|
|
|
var employees2Appointment = new List<Employee2SchedulerAppointmentDC>();
|
|
|
|
Model.SelectedEmployeesForIntervalFinder.DoForEach(employee =>
|
|
{
|
|
employees2Appointment.Add(new Employee2SchedulerAppointmentDC
|
|
{
|
|
Employee = employee
|
|
});
|
|
});
|
|
|
|
Model.SelectedAppointment = new SchedulerAppointmentDC()
|
|
{
|
|
ActivationType = ActivationTypeId.Active,
|
|
IsTask = false,
|
|
IsPrivate = false,
|
|
Originator = MobileSessionFacade.LoggedInCompactEmployee,
|
|
StartDate = startDate,
|
|
EndDate = endDate
|
|
};
|
|
|
|
Model.SelectedCustomers = Model.SelectedCustomersForIntervalFinder.Clone();
|
|
Model.SelectedEmployees = Model.SelectedEmployeesForIntervalFinder.Clone();
|
|
Model.SelectedResources = Model.SelectedResourcesForIntervalFinder.Clone();
|
|
|
|
Model.SelectedCustomersForIntervalFinder.Clear();
|
|
Model.SelectedEmployeesForIntervalFinder.Clear();
|
|
Model.SelectedResourcesForIntervalFinder.Clear();
|
|
|
|
Model.IntervalStartDate = null;
|
|
Model.IntervalEndDate = null;
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
public string ResetIntervalFinder()
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
Model.SelectedCustomersForIntervalFinder.Clear();
|
|
Model.SelectedEmployeesForIntervalFinder.Clear();
|
|
Model.SelectedResourcesForIntervalFinder.Clear();
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult FetchAppointments()
|
|
{
|
|
LoadAppointmentsForDate();
|
|
|
|
return PartialView("OneDaySchedulerPartial", Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectResourcesForAppointmentFiltering(string resourceOids)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(resourceOids);
|
|
|
|
var list = new List<ResourceDC>();
|
|
|
|
Model.ResourceCategories2Resources.Values.DoForEach(l => l.DoForEach(s => list.AddIfNotIn(s)));
|
|
|
|
Model.SelectedResourcesForFiltering = list.Where(resource => resource.ResourceOid.HasValue && oidList.Contains(resource.ResourceOid.Value)).ToList();
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedResourcesForFiltering);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectEmployeesForAppointmentFiltering(string oidString)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedEmployeesForFiltering = Model.AllEmployees.Where(employee => oidList.Contains(employee.EmployeeOid)).ToList();
|
|
|
|
return Model.SelectedEmployeesForFiltering.Count.ToString();
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectCustomersForAppointmentFiltering(string oidString)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var oidList = ConvertOidStringToList(oidString);
|
|
|
|
Model.SelectedCustomersForFiltering = Model.AllCustomers.Where(customer => oidList.Contains(customer.CustomerOid)).ToList();
|
|
|
|
return Model.SelectedCustomersForFiltering.Count.ToString();
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult FetchSelectedEmployeesForPopup()
|
|
{
|
|
return PartialView("EmployeeForFilteringPartial", Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult FetchEmployeeFilteringModalBody()
|
|
{
|
|
return PartialView("EmployeeFilteringModalContentPartial", Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectTeamForFiltering(string teamOidString)
|
|
{
|
|
if(Model?.Employee?.EmployeeOid is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
if(long.TryParse(teamOidString, out var teamOid))
|
|
{
|
|
var team = EmployeeService.FindTeamByOid(teamOid, Model.Employee.EmployeeOid.Value);
|
|
if(!(team is null))
|
|
{
|
|
Model.SelectedEmployeesForFiltering.AddRangeIfElementsNotIn(team.Member);
|
|
}
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[Authorize]
|
|
public string SelectTeamForAppointment(string teamOidString)
|
|
{
|
|
if(Model?.Employee?.EmployeeOid is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var teamMemberOids = new List<long>();
|
|
|
|
if(long.TryParse(teamOidString, out var teamOid))
|
|
{
|
|
var team = EmployeeService.FindTeamByOid(teamOid, Model.Employee.EmployeeOid.Value);
|
|
if(!(team is null))
|
|
{
|
|
Model.SelectedEmployees.AddRangeIfElementsNotIn(team.Member);
|
|
teamMemberOids.AddRangeIfElementsNotIn(team.Member.Select(member => member.EmployeeOid));
|
|
}
|
|
}
|
|
|
|
return JsonConvert.SerializeObject(teamMemberOids);
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult FetchCustomersForFiltering()
|
|
{
|
|
return PartialView("CustomerFilterSelectionPartial", Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult FetchCustomerFilteringModalBody()
|
|
{
|
|
return PartialView("CustomerFilteringModalContentPartial", Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public string SetShouldLoadTasks(bool isChecked)
|
|
{
|
|
try
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
Model.ShouldLoadTasks = isChecked;
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
Log.Error(exception.Message, exception);
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[Authorize]
|
|
public string DeleteAppointment(long appointmentOid)
|
|
{
|
|
if(Model?.Employee?.EmployeeOid is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var appointment = Model.Appointments.FirstOrDefault(app => app.SchedulerAppointmentOid?.Equals(appointmentOid) ?? false);
|
|
|
|
if(!(appointment is null))
|
|
{
|
|
var teamMemberCustomerOids = EmployeeService.LoadTeamsRelatedCustomerOids(Model.Employee.EmployeeOid.Value);
|
|
|
|
var customerList = appointment.CustomerList;
|
|
var employeeList = appointment.EmployeeList;
|
|
var resourceList = appointment.ResourceList;
|
|
var originator = appointment.Originator;
|
|
var isNew = false;
|
|
var checkType = SchedulerRightsCheckType.Edit;
|
|
var loggedOnUser = MobileSessionFacade.LoggedInUserDC;
|
|
|
|
var isAllowedToDelete = BS.Shared.Core.Utils.CheckSchedulerRights(customerList, resourceList, employeeList, originator, isNew, checkType, loggedOnUser, teamMemberCustomerOids);
|
|
|
|
if(isAllowedToDelete && appointment.SchedulerAppointmentOid.HasValue && appointment.NewSchedulerAppointmentVersion.HasValue)
|
|
{
|
|
var oid2Version = new Dictionary<long, long> {{appointment.SchedulerAppointmentOid.Value, appointment.NewSchedulerAppointmentVersion.Value}};
|
|
|
|
KalenderService.DeactivateSchedulerAppointments(oid2Version);
|
|
}
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
}
|
|
}
|