public static bool IsHoliday(DateTime day)
{
return
(NonWorkingDays
.GetNonWorkingDays(day.Year)
.Contains(day));
}
internal static bool isWeekend(this DateOnly thisDate, NonWorkingDays?nonWorkingDays = null)
{
NonWorkingDays considerAsNonWorkingDays = nonWorkingDays ?? new();
DayOfWeek[] weekendDays = considerAsNonWorkingDays.Weekend.ToArray();
return(weekendDays.Contains(thisDate.DayOfWeek));
}
public static IList <DateTime> GetNonWorkingDays(int year)
{
IList <DateTime> days = new List <DateTime>();
days.Add(new DateTime(year, 01, 01));
days.Add(new DateTime(year, 01, 06));
days.Add(new DateTime(year, 04, 25));
days.Add(new DateTime(year, 05, 01));
days.Add(new DateTime(year, 06, 02));
days.Add(new DateTime(year, 06, 24));
days.Add(new DateTime(year, 08, 15));
days.Add(new DateTime(year, 10, 01));
days.Add(new DateTime(year, 12, 08));
days.Add(new DateTime(year, 12, 25));
days.Add(new DateTime(year, 12, 26));
days.Add(NonWorkingDays.EasterDay(year));
days.Add(NonWorkingDays.EasterDay(year).AddDays(1));
DateTime dummy = new DateTime(year, 1, 1);
while (dummy.Year == year)
{
if (!days.Contains(dummy) && dummy.DayOfWeek == DayOfWeek.Saturday || dummy.DayOfWeek == DayOfWeek.Sunday)
{
days.Add(dummy);
}
dummy = dummy.AddDays(1);
}
return(days);//a
}
public void Should_respect_custom_non_working_day_definition()
{
var someDate = new DateOnly(2022, 3, 17); // THU
var nwd = new NonWorkingDays {
CustomNonWorkingsDays = new List <DateOnly> {
someDate
}
};
var isWorkingDayBefore = someDate.IsWorkingDay();
var isNoWorkingDayAfter = !someDate.IsWorkingDay(nwd);
var respectsCustomNonWorkingDayDefinition = isWorkingDayBefore && isNoWorkingDayAfter;
Assert.True(respectsCustomNonWorkingDayDefinition);
}
private void NonWorkingDaysGridView_RowClick(object sender, DevExpress.XtraGrid.Views.Grid.RowClickEventArgs e)
{
nonworkingdays = new NonWorkingDays();
try
{
GridView view = sender as GridView;
object row = view.GetRow(e.RowHandle);
nonworkingdays = (NonWorkingDays)row;
NamteTE.Text = nonworkingdays.Name;
DateMC.SelectionStart = nonworkingdays.Date;
}
catch
{
}
}
public bool Execute(NonWorkingDays nonWorkingDays)
{
try
{
var request = WebRequest.Create("http://localhost:3000/DeleteNeradniDani");
request.Headers["ID"] = nonWorkingDays.ID.ToString();
request.GetResponse();
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
}
public bool Execute(NonWorkingDays nonWorkingDays)
{
try
{
var request = WebRequest.Create("http://localhost:3000/InsertNeradniDan");
request.Headers["name"] = nonWorkingDays.Name;
request.Headers["date_time"] = nonWorkingDays.Date.ToString("yyyy-MM-dd");
request.GetResponse();
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
}
public bool UpdateNonWokringDays(NonWorkingDays nonWorkingDays)
{
try
{
UpdateNonWorkingDays updateNonWorkingDays = new UpdateNonWorkingDays();
updateNonWorkingDays.Execute(nonWorkingDays);
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
finally
{
}
}
public bool InsertNonWorkingDays(NonWorkingDays nonWorkingDays)
{
try
{
InsertNonWorkingDays insertNonWorkingDays = new InsertNonWorkingDays();
insertNonWorkingDays.Execute(nonWorkingDays);
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
finally
{
}
}
public bool DeleteNonWorkingDays(NonWorkingDays nonWorkingDays)
{
try
{
DeleteNonWorkingDays deleteNonWorkingDays = new DeleteNonWorkingDays();
deleteNonWorkingDays.Execute(nonWorkingDays);
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
finally
{
}
}
public int getBusinessDates(DateTime dateSt, DateTime dateNd, NonWorkingDays nonWorkingDays = NonWorkingDays.SaturdaySunday)
{
List <DateTime> datelist = new List <DateTime>();
while (dateSt.Date < dateNd.Date)
{
datelist.Add((dateSt = dateSt.AddDays(1)));
}
if (nonWorkingDays == NonWorkingDays.SaturdaySunday)
{
return(datelist.Count(d => d.DayOfWeek != DayOfWeek.Saturday &&
d.DayOfWeek != DayOfWeek.Friday));
}
else
{
return(datelist.Count(d => d.DayOfWeek != DayOfWeek.Friday &&
d.DayOfWeek != DayOfWeek.Saturday));
}
}
private void NewBarItem_ItemClick(object sender, ItemClickEventArgs e)
{
if (!string.IsNullOrWhiteSpace(NamteTE.Text) && DateMC.SelectionStart != null && DateMC.SelectionStart > DateTime.Now)
{
nonworkingdays = new NonWorkingDays();
nonworkingdays.Date = DateMC.SelectionStart;
nonworkingdays.Name = NamteTE.Text;
if (!_DB.InsertNonWorkingDays(nonworkingdays))
{
XtraMessageBox.Show("Element is not added!");
}
_nonWorkingdays = _DB.GetNonWorkingDays();
NonWorkingDaysGridControl.DataSource = _nonWorkingdays;
NamteTE.Text = string.Empty;
DateMC.SelectionStart = DateTime.Now;
}
else
{
XtraMessageBox.Show("All fields should be filled!");
}
}
public void Should_respect_deviating_weekend_definition()
{
var saturday = new DateOnly(2022, 4, 23);
var sunday = saturday.AddDays(1);
var monday = sunday.AddDays(1);
var tuesday = monday.AddDays(1);
var wednesday = tuesday.AddDays(1);
var thursday = wednesday.AddDays(1);
var friday = thursday.AddDays(1);
//weekend is WED + FRI
var nwd = new NonWorkingDays {
Weekend = new List <DayOfWeek> {
DayOfWeek.Wednesday, DayOfWeek.Friday
}
};
var customWeekendIsWedAndFri = !saturday.isWeekend(nwd) &&
!sunday.isWeekend(nwd) &&
!monday.isWeekend(nwd) &&
!tuesday.isWeekend(nwd) &&
wednesday.isWeekend(nwd) &&
!thursday.isWeekend(nwd) &&
friday.isWeekend(nwd);
//there is no weekend
var nwd2 = new NonWorkingDays {
Weekend = new List <DayOfWeek>()
};
var thereIsNoWeekend = !saturday.isWeekend(nwd2) &&
!sunday.isWeekend(nwd2) &&
!monday.isWeekend(nwd2) &&
!tuesday.isWeekend(nwd2) &&
!wednesday.isWeekend(nwd2) &&
!thursday.isWeekend(nwd2) &&
!friday.isWeekend(nwd2);
Assert.True(customWeekendIsWedAndFri && thereIsNoWeekend);
}
internal static bool isHoliday(this DateOnly thisDate, NonWorkingDays?nonWorkingDays = null)
{
HashSet <DateOnly> holidays = new();
NonWorkingDays considerAsHoliday = nonWorkingDays ?? new();
if (considerAsHoliday.EuropeanTARGET)
{
holidays.UnionWith(Holidays.TargetBankHolidays(thisDate.Year));
}
var selectedState = considerAsHoliday.GermanPublicHolidays;
if (selectedState != GermanState.NONE)
{
holidays.UnionWith(Holidays.GermanPublicHolidays(thisDate.Year, selectedState));
}
if (considerAsHoliday.CustomNonWorkingsDays.Any())
{
holidays.UnionWith(considerAsHoliday.CustomNonWorkingsDays);
}
return(holidays.Contains(thisDate));
}
private void GetMonth(DateTime day)
{
// add holidays
var holidays = new HolidayCalculator(day, Utils.ReadConfig("Holidays", "Path"));
foreach (HolidayCalculator.Holiday h in holidays.OrderedHolidays)
{
if (h.Date.Month == day.Month)
{
Holidays.Add(new Holiday(h.Name, h.Date));
}
// and days before holidays if theye're not weekends or holidays
var yesterday = h.Date.AddDays(-1);
if (yesterday.Month == day.Month &&
Holidays.FirstOrDefault(hl => hl.Date == yesterday) == default(Holiday) &&
yesterday.DayOfWeek != DayOfWeek.Saturday &&
yesterday.DayOfWeek != DayOfWeek.Sunday)
{
SpecialDays.Add(new SpecialDay("Day before " + h.Name, yesterday.Date));
}
}
// if the last day in month is day before holiday
var firstInNextMonth = Last.AddDays(1);
var hol = Holidays.FirstOrDefault(h => h.Date == firstInNextMonth);
if (hol != null &&
Last.Date.DayOfWeek != DayOfWeek.Saturday &&
Last.Date.DayOfWeek != DayOfWeek.Sunday)
{
SpecialDays.Add(new SpecialDay("Day before " + hol.Name, Last.Date));
}
// get all fridays, if they're not holidays
var startDate = First;
while (startDate.DayOfWeek != DayOfWeek.Friday)
{
startDate = startDate.AddDays(1);
}
while (startDate < Last)
{
if (Holidays.FirstOrDefault(h => h.Date == startDate) == default(Holiday))
{
SpecialDays.Add(new SpecialDay("Friday", startDate));
}
startDate = startDate.AddDays(7);
}
// get all weekends, if they're not holidays
startDate = First;
while (startDate.DayOfWeek != DayOfWeek.Saturday)
{
startDate = startDate.AddDays(1);
}
while (startDate < Last)
{
if (Holidays.FirstOrDefault(h => h.Date == startDate) == default(Holiday))
{
NonWorkingDays.Add(new NonWorkingDay(startDate));
}
startDate = startDate.AddDays(1);
if (Holidays.FirstOrDefault(h => h.Date == startDate) == default(Holiday))
{
NonWorkingDays.Add(new NonWorkingDay(startDate));
}
startDate = startDate.AddDays(6);
}
}
public void Should_correctly_calculate_next_working_day(NonWorkingDays nwd, DateOnly current, DateOnly expected)
{
var actual = current.GetNextWorkingDay(nwd);
Assert.Equal(expected, actual);
}
protected static bool IsNonWorkingDay(DateTime date)
{
var dt = date.Date;
return(NonWorkingDays.IsWeekend(dt) || NonWorkingDays.IsBankHoliday(dt));
}
