476 lines
15 KiB
C#
476 lines
15 KiB
C#
using Aperio_Control_Centre.ACSDatabase.Types;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.ComponentModel.DataAnnotations.Schema;
|
|
|
|
namespace Aperio_Control_Centre.ACSDatabase.Models
|
|
{
|
|
public class Timezone
|
|
{
|
|
[Key]
|
|
[Display(Name = nameof(Id))]
|
|
public int Id { get; set; }
|
|
|
|
[Required]
|
|
[Display(Name = nameof(Name))]
|
|
[MaxLength(50)]
|
|
[Remote(action: "VerifyName", controller: "Timezone", AdditionalFields = "Id")]
|
|
public string Name { get; set; } = string.Empty;
|
|
|
|
[Display(Name = nameof(BeginTime))]
|
|
[DataType(DataType.Time)]
|
|
[DisplayFormat(DataFormatString = @"{0:hh\:mm}", ApplyFormatInEditMode = true)]
|
|
public TimeSpan BeginTime { get; set; }
|
|
|
|
//TODO: in database gebruikt datetime2
|
|
[Display(Name = nameof(EndTime))]
|
|
[DataType(DataType.Time)]
|
|
[DisplayFormat(DataFormatString = @"{0:hh\:mm}", ApplyFormatInEditMode = true)]
|
|
public TimeSpan EndTime { get; set; }
|
|
|
|
[Display(Name = nameof(WeekDays))]
|
|
public Types.WeekDaysTypes WeekDays { get; set; }
|
|
|
|
[Display(Name = nameof(TwentyFourHours))]
|
|
public Types.TwentyFourHoursTypes TwentyFourHours { get; set; }
|
|
|
|
[DataType(DataType.MultilineText)]
|
|
[Display(Name = nameof(Info))]
|
|
[MaxLength(500)]
|
|
public string? Info { get; set; }
|
|
|
|
[Required]
|
|
public Types.ActiveStates Active { get; set; }
|
|
|
|
[Required]
|
|
[Display(Name = nameof(LastChanged))]
|
|
[DisplayFormat(DataFormatString = "{0:dd-MM-yyyy HH:mm:ss}", ApplyFormatInEditMode = true)]
|
|
public DateTime LastChanged { get; set; }
|
|
|
|
|
|
[Display(Name = nameof(Devices))]
|
|
public ICollection<Device>? Devices { get; set; }
|
|
|
|
[Obsolete("Old user groups")]
|
|
[Display(Name = nameof(Groups))]
|
|
public ICollection<Group>? Groups { get; set; }
|
|
|
|
[Display(Name = nameof(Authorizations))]
|
|
public ICollection<AuthorizationEntry> Authorizations { get; } = [];
|
|
|
|
[Display(Name = nameof(DoorModeSchedules))]
|
|
public ICollection<DoorModeSchedule> DoorModeSchedules { get; } = [];
|
|
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
|
|
[NotMapped]
|
|
[Display(Name = nameof(Monday))]
|
|
public bool Monday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Monday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Monday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Monday);
|
|
}
|
|
}
|
|
[NotMapped]
|
|
[Display(Name = nameof(Tuesday))]
|
|
public bool Tuesday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Tuesday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Tuesday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Tuesday);
|
|
}
|
|
}
|
|
[NotMapped]
|
|
[Display(Name = nameof(Wednesday))]
|
|
public bool Wednesday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Wednesday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Wednesday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Wednesday);
|
|
}
|
|
}
|
|
|
|
[NotMapped]
|
|
[Display(Name = nameof(Thursday))]
|
|
public bool Thursday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Thursday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Thursday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Thursday);
|
|
}
|
|
}
|
|
[NotMapped]
|
|
[Display(Name = nameof(Friday))]
|
|
public bool Friday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Friday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Friday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Friday);
|
|
}
|
|
}
|
|
[NotMapped]
|
|
[Display(Name = nameof(Saturday))]
|
|
public bool Saturday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Saturday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Saturday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Saturday);
|
|
}
|
|
}
|
|
[NotMapped]
|
|
[Display(Name = nameof(Sunday))]
|
|
public bool Sunday
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Sunday);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDays.SetFlag(WeekDaysTypes.Sunday);
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Sunday);
|
|
}
|
|
}
|
|
|
|
[NotMapped]
|
|
[Display(Name = nameof(AllDays))]
|
|
public bool AllDays
|
|
{
|
|
get
|
|
{
|
|
return WeekDays.HasFlag(WeekDaysTypes.Daily);
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
WeekDays = WeekDaysTypes.Daily;
|
|
else
|
|
WeekDays = WeekDays.ClearFlag(WeekDaysTypes.Daily);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
[NotMapped]
|
|
[Display(Name = nameof(WholeDayTime))]
|
|
public bool WholeDayTime
|
|
{
|
|
get
|
|
{
|
|
if (TwentyFourHours == TwentyFourHoursTypes.TwentyFourHours)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
TwentyFourHours = TwentyFourHoursTypes.TwentyFourHours;
|
|
else
|
|
TwentyFourHours = TwentyFourHoursTypes.Timeselected;
|
|
}
|
|
}
|
|
|
|
|
|
[NotMapped]
|
|
[Display(Name = nameof(Id))]
|
|
public string GetTimezoneString
|
|
{
|
|
get
|
|
{
|
|
string _timezonestring;
|
|
if (this.TwentyFourHours == TwentyFourHoursTypes.TwentyFourHours)
|
|
{
|
|
_timezonestring = "24 uur";
|
|
}
|
|
else
|
|
{
|
|
_timezonestring = $"{BeginTime.ToString(@"hh\:mm")} - {EndTime.ToString(@"hh\:mm")}";
|
|
}
|
|
_timezonestring += $" ({GetWeekdayShortString})";
|
|
return _timezonestring;
|
|
}
|
|
}
|
|
|
|
[NotMapped]
|
|
[Display(Name = "Weekday")]
|
|
public string GetWeekdayShortString
|
|
{
|
|
get
|
|
{
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Daily))
|
|
{
|
|
return "dagelijks";
|
|
}
|
|
|
|
var days = new List<string>();
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Monday))
|
|
{
|
|
days.Add("ma");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Tuesday))
|
|
{
|
|
days.Add("di");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Wednesday))
|
|
{
|
|
days.Add("wo");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Thursday))
|
|
{
|
|
days.Add("do");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Friday))
|
|
{
|
|
days.Add("vr");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Saturday))
|
|
{
|
|
days.Add("za");
|
|
}
|
|
if (WeekDays.HasFlag(WeekDaysTypes.Sunday))
|
|
{
|
|
days.Add("zo");
|
|
}
|
|
|
|
if (days.Count == 0) return "nooit";
|
|
if (days.Count == 1) return days.First();
|
|
return string.Join(",", days.Where(s => !string.IsNullOrEmpty(s)));
|
|
}
|
|
}
|
|
|
|
public string BeginTimeString()
|
|
{
|
|
if (TwentyFourHours == TwentyFourHoursTypes.TwentyFourHours)
|
|
{
|
|
return "24 uur";
|
|
}
|
|
return BeginTime.ToString(@"hh\:mm");
|
|
}
|
|
|
|
public string EndTimeString()
|
|
{
|
|
if (TwentyFourHours == TwentyFourHoursTypes.TwentyFourHours)
|
|
{
|
|
return "24 uur";
|
|
}
|
|
return EndTime.ToString(@"hh\:mm");
|
|
}
|
|
|
|
//[Display(Name = "Apparaten")]
|
|
public IEnumerable<Device> DevicesList()
|
|
{
|
|
return Devices?.Where(m => m.Active != ActiveStates.Deleted) ?? [];
|
|
}
|
|
|
|
//[Display(Name = "Apparaten")]
|
|
public IEnumerable<DoorModeSchedule> DoorModeSchedulesList()
|
|
{
|
|
return DoorModeSchedules.Where(m => m.Device?.Active != ActiveStates.Deleted) ?? [];
|
|
}
|
|
|
|
public bool IsUsed()
|
|
{
|
|
return (!DevicesList().Any() && Authorizations.Count == 0 && !DoorModeSchedulesList().Any());
|
|
}
|
|
|
|
//[Display(Name = "Tijdzone actief")]
|
|
public bool IsTimezoneActive()
|
|
{
|
|
return IsTimezoneActive(DateTime.Now);
|
|
}
|
|
|
|
//[Display(Name = "Tijdzone actief")]
|
|
public bool IsTimezoneActive(DateTime dateTime)
|
|
{
|
|
if (WeekDays == 0)
|
|
{
|
|
return false;
|
|
}
|
|
if (WeekDays == WeekDaysTypes.Daily && TwentyFourHours == TwentyFourHoursTypes.TwentyFourHours)
|
|
{
|
|
return true;
|
|
}
|
|
//check time block
|
|
if (TwentyFourHours == TwentyFourHoursTypes.Timeselected)
|
|
{
|
|
TimeSpan now = dateTime.TimeOfDay;
|
|
if (TimeSpan.Compare(now, BeginTime) != 1 || TimeSpan.Compare(now, EndTime) != -1)
|
|
{
|
|
//outside time block
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//Check weekdays
|
|
if (WeekDays != WeekDaysTypes.Daily)
|
|
{
|
|
DayOfWeek today = dateTime.DayOfWeek;
|
|
|
|
if (today == DayOfWeek.Monday && Monday)
|
|
return true;
|
|
if (today == DayOfWeek.Tuesday && Tuesday)
|
|
return true;
|
|
if (today == DayOfWeek.Wednesday && Wednesday)
|
|
return true;
|
|
if (today == DayOfWeek.Thursday && Thursday)
|
|
return true;
|
|
if (today == DayOfWeek.Friday && Friday)
|
|
return true;
|
|
if (today == DayOfWeek.Saturday && Saturday)
|
|
return true;
|
|
if (today == DayOfWeek.Sunday && Sunday)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
public TimeSpan TimeToNextBeginTime()
|
|
{
|
|
return TimeToNextTime(BeginTime, DateTime.Now);
|
|
}
|
|
public TimeSpan TimeToNextBeginTime(DateTime dateTime)
|
|
{
|
|
return TimeToNextTime(BeginTime, dateTime);
|
|
}
|
|
|
|
public TimeSpan TimeToNextEndTime()
|
|
{
|
|
return TimeToNextTime(EndTime, DateTime.Now);
|
|
}
|
|
public TimeSpan TimeToNextEndTime(DateTime dateTime)
|
|
{
|
|
return TimeToNextTime(EndTime, dateTime);
|
|
}
|
|
|
|
|
|
private TimeSpan TimeToNextTime(TimeSpan time, DateTime currentDateTime)
|
|
{
|
|
//Debug.WriteLine($"-----------------------------------------------------------");
|
|
//Debug.WriteLine($"currentDateTime {currentDateTime.ToString()} - {currentDateTime.DayOfWeek}");
|
|
//Debug.WriteLine($"time {time.ToString()}");
|
|
|
|
if (WeekDays == WeekDaysTypes.Daily)
|
|
{
|
|
return RemainingTimeOffDay(time, currentDateTime.TimeOfDay);
|
|
}
|
|
else if (WeekDays == WeekDaysTypes.None)
|
|
{
|
|
return TimeSpan.Zero;
|
|
}
|
|
else
|
|
{
|
|
//Debug.WriteLine($"day of week {today}");
|
|
|
|
WeekDaysTypes weekday = currentDateTime.DayOfWeek.ToWeekDaysTypes();
|
|
if (WeekDays.HasFlag(weekday))
|
|
{
|
|
//Debug.WriteLine("has flag");
|
|
if (time > currentDateTime.TimeOfDay)
|
|
{
|
|
//on the same day
|
|
//Debug.WriteLine($"Same day");
|
|
return RemainingTimeOffDay(time, currentDateTime.TimeOfDay);
|
|
}
|
|
}
|
|
|
|
IOrderedEnumerable<DayOfWeek> reordereddays = Enum.GetValues<DayOfWeek>()
|
|
.Cast<DayOfWeek>()
|
|
.OrderBy(d => (d - (currentDateTime.DayOfWeek + 1) + 7) % 7);
|
|
|
|
TimeSpan days = new();
|
|
foreach (DayOfWeek day in reordereddays)
|
|
{
|
|
//Debug.WriteLine($"----- day = {day}");
|
|
WeekDaysTypes? wday = day.ToWeekDaysTypes();
|
|
if (WeekDays.HasFlag(wday.Value))
|
|
{
|
|
//Debug.WriteLine($"wday has flag {wday.Value}");
|
|
//Debug.WriteLine($"+ Add day - {days.TotalDays}");
|
|
days = days.Add(TimeSpan.FromDays(1));
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//Debug.WriteLine($"++ Add day - {days.TotalDays}");
|
|
days = days.Add(TimeSpan.FromDays(1));
|
|
}
|
|
}
|
|
//Debug.WriteLine($"Total Days = {days.TotalDays}");
|
|
//Debug.WriteLine($"Total Days = {days.Days}");
|
|
|
|
TimeSpan remaining = time - currentDateTime.TimeOfDay;
|
|
//Debug.WriteLine($"Remaining {remaining.TotalSeconds} sec - {remaining.TotalHours} hr");
|
|
days = days.Add(remaining);
|
|
//Debug.WriteLine($"Days = {days.TotalDays}");
|
|
return days;
|
|
}
|
|
}
|
|
|
|
private static TimeSpan RemainingTimeOffDay(TimeSpan time, TimeSpan currentTime)
|
|
{
|
|
TimeSpan remaining = time - currentTime;
|
|
//Debug.WriteLine($"Remaining {remaining.TotalSeconds} sec - {remaining.TotalHours} hr");
|
|
if (remaining.TotalSeconds < 0)
|
|
{
|
|
remaining = remaining.Add(TimeSpan.FromDays(1));
|
|
}
|
|
//Debug.WriteLine($"Remaining +24hr {remaining.TotalSeconds} sec - {remaining.TotalHours} hr");
|
|
return remaining;
|
|
}
|
|
}
|
|
}
|