349 lines
14 KiB
C#
349 lines
14 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 BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
|
|
using DevExpress.XtraScheduler;
|
|
using DevExpress.XtraScheduler.Compatibility;
|
|
|
|
using static BeWoPlanerMobil.Util.MobileUtils;
|
|
|
|
namespace BeWoPlanerMobil.Controllers
|
|
{
|
|
public class SchedulerController : AbstractBaseController
|
|
{
|
|
private const string SchedulerModelSessionKey = "SchedulerModel";
|
|
|
|
private SchedulerModel _Model;
|
|
public SchedulerModel Model
|
|
{
|
|
get
|
|
{
|
|
if (!MobileSessionFacade.IsUserLoggedIn())
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
return null;
|
|
}
|
|
|
|
if (((SchedulerModel) Session[SchedulerModelSessionKey])?.Employee == null)
|
|
{
|
|
_Model = new SchedulerModel { Employee = MobileSessionFacade.LoggedInEmployee };
|
|
Session[SchedulerModelSessionKey] = _Model;
|
|
}
|
|
else
|
|
{
|
|
_Model = (SchedulerModel) Session[SchedulerModelSessionKey];
|
|
}
|
|
|
|
return _Model;
|
|
}
|
|
}
|
|
|
|
|
|
[Authorize]
|
|
public ActionResult Scheduler()
|
|
{
|
|
if (!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeScheduler)
|
|
{
|
|
return RedirectToActionPermanent("Index", "Login");
|
|
}
|
|
|
|
LoadAppointmentsForDate();
|
|
|
|
LoadBeWoTasksToModel();
|
|
|
|
return View(Model);
|
|
}
|
|
|
|
private void LoadAppointmentsForDate()
|
|
{
|
|
if(Model?.Employee.EmployeeOid == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var date = Model.SelectedDate;
|
|
|
|
var appointments = KalenderService.LoadFilteredAppointmentsMitAufgaben(AbstractModel.HasRightToSeeAllEmployeeAppointments, Model.Employee.EmployeeOid.Value, date.Date, date.Date.AddDays(1), new List<long>(), new List<long>(), new List<long>(), false, false, false, false, true, true).ToList();
|
|
|
|
// Nur eigene Kliententermine ansehen
|
|
if(!AbstractModel.HasRightToSeeAllCustomerAppointments)
|
|
{
|
|
appointments = appointments.Where(a => a.CustomerList.All(c => MobileSessionFacade.LoggedInEmployee.RelatedCustomers.Any(rc => rc.Customer.Equals(c)))).ToList();
|
|
}
|
|
|
|
if(!AbstractModel.HasRightToSeeAllResourceAppointments)
|
|
{
|
|
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.StartDate.HasValue && w.EndDate.HasValue &&
|
|
((date.InBetween(w.StartDate.Value, w.EndDate.Value, false) ||
|
|
date.CompareShortDates(w.StartDate.Value)) && w.RecurrenceInfo == null ||
|
|
w.RecurrenceInfo != null && (w.Type == 3 || w.Type == 4) &&
|
|
(date.InBetween(w.StartDate.Value, w.EndDate.Value, false) ||
|
|
date.CompareShortDates(w.StartDate.Value)))).ToList();
|
|
|
|
var deletedOccurrences = holySweetFlyingFuck.Where(w => w.Type == 4).Select(s => GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
var changedOccurrences = holySweetFlyingFuck.Where(w => w.Type == 3).Select(s => GetOccurrenceId(s.RecurrenceInfo)).ToList();
|
|
|
|
holySweetFlyingFuck = holySweetFlyingFuck.Where(w => w.Type != 4).ToList();
|
|
|
|
foreach(var appointment in appointments)
|
|
{
|
|
if(appointment.RecurrenceInfo != null && appointment.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 interval = new TimeInterval(date, date.AddDays(1));
|
|
|
|
var occurrences = occurrenceCalculator.CalcOccurrences(interval, pattern);
|
|
|
|
if(occurrences.Count > 0)
|
|
{
|
|
foreach(var termin in occurrences.GetAppointments(interval))
|
|
{
|
|
var index = termin.RecurrenceIndex;
|
|
|
|
var duration = (appointment.EndDate.Value - appointment.StartDate.Value).TotalMinutes;
|
|
|
|
if(!date.InBetween(termin.Start.GetShortDateTime(), termin.Start.AddMinutes(duration),
|
|
true) || changedOccurrences.Any(a =>
|
|
a.PatternId.Equals(patternId) && a.Index == index) ||
|
|
deletedOccurrences.Any(a => a.PatternId.Equals(patternId) && a.Index == index))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
holySweetFlyingFuck.AddIfNotIn(new SchedulerAppointmentDC
|
|
{
|
|
AllDay = appointment.AllDay,
|
|
CustomerList = appointment.CustomerList,
|
|
Description = appointment.Description,
|
|
EmployeeList = appointment.EmployeeList,
|
|
EndDate = termin.Start.AddMinutes(duration),
|
|
FormerBookingSequenceOid = appointment.FormerBookingSequenceOid,
|
|
IsPrivate = appointment.IsPrivate,
|
|
LabelId = appointment.LabelId,
|
|
Location = appointment.Location,
|
|
Originator = appointment.Originator,
|
|
RecurrenceInfo = termin.RecurrenceInfo.ToXml(),
|
|
ReminderInfo = appointment.ReminderInfo,
|
|
ResourceList = appointment.ResourceList,
|
|
StartDate = termin.Start,
|
|
Subject = appointment.Subject ?? "",
|
|
Type = appointment.Type
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Model.Appointments = holySweetFlyingFuck;
|
|
}
|
|
|
|
private void LoadBeWoTasksToModel()
|
|
{
|
|
if (Model?.Employee?.EmployeeOid == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Model.Tasks = AnalysisService.GetTasksForEmployeeByDate(Model.Employee.EmployeeOid.Value, Model.SelectedDate);
|
|
}
|
|
|
|
[Authorize]
|
|
public string UpdateAppointment(long oid, string betreff, string notice, string startZeit, string endZeit, string day, string endDate, string pLocation)
|
|
{
|
|
try
|
|
{
|
|
if (Model == null)
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var date = DateTime.Parse(day);
|
|
var end = DateTime.Parse(endDate);
|
|
var zeit = ConvertRecordTimesWithEndDate(startZeit, endZeit, date, end, 0);
|
|
|
|
var b1 = KalenderService.GetSchedulerAppointmentByid(oid);
|
|
|
|
b1.EndDate = zeit[1];
|
|
b1.StartDate = zeit[0];
|
|
b1.Subject = betreff;
|
|
b1.Description = notice;
|
|
b1.Location = pLocation;
|
|
|
|
KalenderService.UpdateSchedulerAppointments(new List<SchedulerAppointmentDC> { b1 });
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
return SerializeObject("Fehler 550: Internal Server Error");
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult InsertOrUpdateAppointment(FormCollection formCollection)
|
|
{
|
|
try
|
|
{
|
|
if (Model == null)
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
}
|
|
|
|
var rawStartDate = formCollection["StartDate"];
|
|
var rawEndDate = formCollection["EndDate"];
|
|
var rawStartTime = formCollection["StartTime"];
|
|
var rawEndTime = formCollection["EndTime"];
|
|
var subject = formCollection["Subject"];
|
|
var location = formCollection["Location"];
|
|
var notice = formCollection["Notice"];
|
|
|
|
var isSuccessfulStartDate = DateTime.TryParseExact(rawStartDate, "dd.MM.yyyy", null, DateTimeStyles.None, out var startDate);
|
|
var isSuccessfulStartTime = DateTime.TryParseExact(rawStartTime, "HH:mm", null, DateTimeStyles.None, out var startTime);
|
|
var isSuccessfulEndDate = DateTime.TryParseExact(rawEndDate, "dd.MM.yyyy", null, DateTimeStyles.None, out var endDate);
|
|
var isSuccessfulEndTime = DateTime.TryParseExact(rawEndTime, "HH:mm", null, DateTimeStyles.None, out var endTime);
|
|
|
|
if (isSuccessfulStartDate && isSuccessfulStartTime && isSuccessfulEndDate && isSuccessfulEndTime)
|
|
{
|
|
startDate = startDate.MergeDatesByDate(startTime);
|
|
endDate = endDate.MergeDatesByDate(endTime);
|
|
|
|
var appointmentToInsert = Model.SelectedAppointment ?? new SchedulerAppointmentDC();
|
|
|
|
appointmentToInsert.EmployeeList = new List<Employee2SchedulerAppointmentDC>();
|
|
appointmentToInsert.CustomerList = new List<CompactCustomerDC>();
|
|
appointmentToInsert.ResourceList = new List<ResourceDC>();
|
|
appointmentToInsert.SupportConceptList = new List<CompactSupportConceptDC>();
|
|
appointmentToInsert.EndDate = endDate;
|
|
appointmentToInsert.StartDate = startDate;
|
|
appointmentToInsert.Subject = subject;
|
|
appointmentToInsert.Description = notice;
|
|
appointmentToInsert.Originator = MobileSessionFacade.LoggedInCompactEmployee;
|
|
appointmentToInsert.Location = location;
|
|
|
|
if (appointmentToInsert.SchedulerAppointmentOid.HasValue)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult NavigateToPreviousDate()
|
|
{
|
|
if (Model == null)
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
}
|
|
|
|
Model.SelectedDate = Model.SelectedDate.AddDays(-1);
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult NavigateToNextDate()
|
|
{
|
|
if(Model == null)
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
}
|
|
|
|
Model.SelectedDate = Model.SelectedDate.AddDays(1);
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SelectSchedulerDate(FormCollection formCollection) {
|
|
if (Model == null)
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
}
|
|
|
|
var rawSchedulerDate = formCollection["SchedulerDate"];
|
|
|
|
var schedulerDate = DateTime.ParseExact(rawSchedulerDate, "dd.MM.yyyy", null);
|
|
|
|
Model.SelectedDate = schedulerDate;
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult SelectAppointmentToEdit(FormCollection formCollection)
|
|
{
|
|
var rawOid = formCollection["scheduler-oid-holder"];
|
|
|
|
var isSuccessful = long.TryParse(rawOid, out var appointmentOid);
|
|
|
|
if (isSuccessful)
|
|
{
|
|
Model.SelectedAppointment = Model.Appointments.FirstOrDefault(app => app.SchedulerAppointmentOid.HasValue && app.SchedulerAppointmentOid.Value == appointmentOid);
|
|
}
|
|
|
|
return RedirectToActionPermanent("Scheduler");
|
|
}
|
|
|
|
public JsonResult ResetSelectedAppointment()
|
|
{
|
|
if (Model != null)
|
|
{
|
|
Model.SelectedAppointment = null;
|
|
}
|
|
|
|
return Json(null);
|
|
}
|
|
}
|
|
}
|