public async Task <ActionResult <Dictionary <int, ICollection <object> > > > GetYearsAndWeeks([FromQuery] int years)
{
var dict = new Dictionary <int, List <object> >();
var currentYear = DateTime.Now.Year;
for (int i = currentYear - years; i <= currentYear; i++)
{
var numberOfWeeks = ISOWeek.GetWeeksInYear(i);
dict.Add(i, new List <object>());
for (int j = 1; j <= numberOfWeeks; j++)
{
if (i == DateTime.Now.Year && ISOWeek.GetWeekOfYear(DateTime.Now) - 1 < j)
{
break;
}
var weekString = ISOWeek.ToDateTime(i, j, DayOfWeek.Monday).ToString("dd.MM.yyyy")
+ " - "
+ ISOWeek.ToDateTime(i, j, DayOfWeek.Sunday).ToString("dd.MM.yyyy");
dict[i].Add(new { weekNum = j, week = weekString });
}
}
return(Ok(dict));
}
public async Task <IEnumerable <Tracking> > GetPersonTrackingsOfWeek(int year, int personId, int weekNum)
{
DateTime startDate;
DateTime endDate;
var possibleStartDate = ISOWeek.ToDateTime(year, weekNum, DayOfWeek.Monday);
if (possibleStartDate.Year > year)
{
throw new ArgumentException($"Week {weekNum} doesn`t exist in this year");
}
if (possibleStartDate.Year < year)
{
possibleStartDate = new DateTime(year, 1, 1);
}
startDate = possibleStartDate;
int daysToEnd = 7 - (int)startDate.DayOfWeek;
var possibleEndDate = startDate.AddDays(daysToEnd);
if (possibleEndDate.Year > startDate.Year)
{
endDate = new DateTime(startDate.Year, 12, 31);
}
else
{
endDate = possibleEndDate;
}
return(await repository.GetPersonTrackingsOfDateRange(personId, startDate, endDate));
}
public IEnumerable <EmployeeActivity> GetEmployeeActivitiePerWeek(int employeeId, int weekNumber)
{
var firstDayOfWeek = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Monday);
var lastDayOfWeek = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Sunday);
var r = GetEmployeeActivitiyPerPeriod(employeeId, a => a.Date.Date >= firstDayOfWeek.Date && a.Date.Date <= lastDayOfWeek.Date.Date);
return(r);
}
public (DateTime startDate, DateTime endDate) GetStartAndEndDateBasedOnWeek(int weekNumber)
{
//Should be an own class.
var startDate = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Monday);
var endDate = startDate.AddDays(6);
return(startDate, endDate);
}
public static Period FromWeekNumber(int year, int weekNumber)
{
if (year < 1900 || year > 2100)
{
throw new ArgumentOutOfRangeException(nameof(year), "Year is not in a reasonable range (1900-2100)");
}
var startDate = ISOWeek.ToDateTime(year, weekNumber, DayOfWeek.Monday);
var endDate = startDate.AddDays(6);
return(new Period(startDate, endDate));
}
public static Week FromYearAndWeekNumber(int year, int weekNumber)
{
var start = ISOWeek.ToDateTime(year, weekNumber, DayOfWeek.Monday);
var end = start.AddDays(7).AddMilliseconds(-1);
return(new Week
{
Year = year,
WeekNumber = weekNumber,
Start = start,
End = end
});
}
private DateRange GetStartAndEndDateForWeek(int week)
{
if (week < 1 || week > 53)
{
throw new ArgumentOutOfRangeException("The week parameter must be in the range 1 through 53");
}
var date = ISOWeek.ToDateTime(DateTime.Today.Year, week, DayOfWeek.Monday);
return(new DateRange
{
FirstDayInWeek = GetDateForSpecificDay(date),
LastDayInWeek = GetDateForSpecificDay(date).AddDays(6)
});
}
public async Task <IEnumerable <Activity> > GetActivities(int year, int week, string?teamName = null)
{
var weekEnd = new DateTimeOffset(ISOWeek.ToDateTime(year, week, DayOfWeek.Sunday));
var weekEndFilter = Builders <Activity> .Filter.Lte(a => a.DateTime, weekEnd);
var weekStart = weekEnd.Subtract(TimeSpan.FromDays(6));
var startWeekFilter = Builders <Activity> .Filter.Gte(a => a.DateTime, weekStart);
var cursor = await _db.GetCollection <Activity>("Activities").FindAsync(weekEndFilter & startWeekFilter);
var activities = await cursor.ToListAsync();
if (teamName != null)
{
return(activities.Where(a => a.User.Team.Equals(teamName, StringComparison.InvariantCultureIgnoreCase)));
}
return(activities);
}
public async Task <Tax> PostTaxWeekly(TaxDto taxDto)
{
Frequency frequency = Frequency.Weekly;
// provide dates for weekly schedule
int year = DateTime.Now.Year;
DateTime startDate = ISOWeek.ToDateTime(year, taxDto.Week, DayOfWeek.Monday);
DateTime endDate = ISOWeek.ToDateTime(year, taxDto.Week, DayOfWeek.Sunday);
Tax tax = new Tax()
{
Municipality = taxDto.Municipality,
Frequency = frequency,
StartDate = startDate,
EndDate = endDate,
TaxAmount = taxDto.TaxAmount
};
return(await AddTax(tax));
}
public async Task InsertRanks(int year, int week, IEnumerable <RankInputModel> input)
{
var ranksCollection = this.db.GetCollection <Rank>("Ranks");
var t = ISOWeek.GetWeeksInYear(year - 1);
Expression <Func <Rank, bool> > filter;
if (week == 1)
{
filter = rank => rank.Year == year - 1 && rank.Week == t;
}
else
{
filter = rank => rank.Year == year && rank.Week == week - 1;
}
var previousRanks = (await ranksCollection.AsQueryable()
.Where(filter)
.Select(rank => new { rank.PlayerId, rank.RankNumber })
.ToListAsync())
.ToDictionary(rank => rank.PlayerId, rank => rank.RankNumber);
var ranks = mapper.Map <IEnumerable <Rank> >(input).ToList();
ranks.ForEach(rank =>
{
rank.Year = year;
rank.Week = week;
rank.WeekDuration =
ISOWeek.ToDateTime(year, week, DayOfWeek.Monday).ToString("dd.MM.yyyy")
+ " - "
+ ISOWeek.ToDateTime(year, week, DayOfWeek.Sunday).ToString("dd.MM.yyyy");
rank.PreviousRankNumber = previousRanks.ContainsKey(rank.PlayerId) ? previousRanks[rank.PlayerId] : 0;
});
await ranksCollection.InsertManyAsync(ranks);
}
public static DateTime FirstDateOfISO8601Week(int year, int weekNum) => ISOWeek.ToDateTime(year, weekNum, DayOfWeek.Monday);
// GET: DutyRosters
public async Task <IActionResult> Index(short searchYear, short searchWeek, short weekChange)
{
var employees = from e in _context.Employees
select e;
var groups = from g in _context.Groups
select g;
CultureInfo myCI = new CultureInfo("de-DE");
Calendar myCal = myCI.Calendar;
// Gets the DTFI properties required by GetWeekOfYear.
CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule;
System.DayOfWeek myFirstDOW = myCI.DateTimeFormat.FirstDayOfWeek;
var dutyRoster = new DutyRoster();
if (searchYear > 0 && searchWeek > 0)
{
if (weekChange == -1)
{
if (searchWeek == 1)
{
dutyRoster.Year = (short)(searchYear - 1);
dutyRoster.Week = 52;
}
else
{
dutyRoster.Year = searchYear;
dutyRoster.Week = (short)(searchWeek - 1);
}
}
else if (weekChange == 1)
{
if (searchWeek == 52)
{
dutyRoster.Year = (short)(searchYear + 1);
dutyRoster.Week = 1;
}
else
{
dutyRoster.Year = searchYear;
dutyRoster.Week = (short)(searchWeek + 1);
}
}
else
{
dutyRoster.Year = searchYear;
dutyRoster.Week = searchWeek;
}
}
else
{
// Displays the number of the current week relative to the beginning of the year.
//Console.WriteLine("The CalendarWeekRule used for the en-US culture is {0}.", myCWR);
//Console.WriteLine("The FirstDayOfWeek used for the en-US culture is {0}.", myFirstDOW);
//Console.WriteLine("Therefore, the current week is Week {0} of the current year.", myCal.GetWeekOfYear(DateTime.Now, myCWR, myFirstDOW));
dutyRoster.Year = (short)DateTime.Today.Year;
dutyRoster.Week = (short)myCal.GetWeekOfYear(DateTime.Now, myCWR, myFirstDOW);
}
var rosters = from r in _context.DutyRosters
where r.Year == dutyRoster.Year && r.Week == dutyRoster.Week
select r;
var joinedDataRostersEmployees = rosters.AsQueryable().Join
(employees,
roster => roster.EmployeeId,
empoyee => empoyee.Id,
(roster, employee) =>
new
{
Id = roster.Id,
Year = roster.Year,
Week = roster.Week,
Day = roster.Day,
GroupId = roster.GroupId,
EmployeeId = roster.EmployeeId,
StartTime = roster.StartTime,
EndTime = roster.EndTime,
EmployeeName = employee.Surname + ", " + employee.Forename
});
List <DutyRosterModel> dutyRosterModels = new List <DutyRosterModel>();
foreach (var item in joinedDataRostersEmployees)
{
dutyRosterModels.Add(
new DutyRosterModel
{
Id = item.Id,
Year = item.Year,
Week = item.Week,
Day = item.Day,
GroupId = item.GroupId,
EmployeeId = item.EmployeeId,
StartTime = item.StartTime,
EndTime = item.EndTime,
EmployeeName = item.EmployeeName
}
);
}
var firstDayInWeek = ISOWeek.ToDateTime(dutyRoster.Year, dutyRoster.Week, myFirstDOW).Date;
var daysOfWeek = new List <Models.DayOfWeek>();
Models.DayOfWeek dayOfWeek = new Models.DayOfWeek();
for (int i = 0; i < 7; i++)
{
dayOfWeek = new Models.DayOfWeek
{
Index = i,
DayName = firstDayInWeek.AddDays(i).DayOfWeek.ToString(),
Date = firstDayInWeek.AddDays(i)
};
daysOfWeek.Add(dayOfWeek);
}
var dutyRosterModel = new DutyRosterIndexModel
{
DutyRosters = dutyRosterModels,
Employees = await employees.ToListAsync(),
Groups = await groups.ToListAsync(),
DutyRoster = dutyRoster,
DaysOfWeek = daysOfWeek
};
return(View(dutyRosterModel));
}
public async Task <BookingResponse> GetBookingsWeek(BookingsWeekRequest model)
{
// Get activity and check if it exists
var activity = await _bookingDbContext.Activities.Include(a => a.Bookings)
.Where(a => a.Id == model.ActivityId).FirstAsync();
if (activity == null)
{
return(new BookingResponse(400, "Activity does not exist"));
}
var date = DateTime.Now;
// Check if year is in the before or more than 1 year after current year
if (model.Year < date.Year || model.Year > date.Year + 1)
{
return(new BookingResponse(400, "Year must be current or next year"));
}
// Check if week is before current week
if (model.Year == date.Year && model.Week < ISOWeek.GetWeekOfYear(date))
{
return(new BookingResponse(400, "Week must be in the future"));
}
// Check if week is less than 1
if (model.Week < 1)
{
return(new BookingResponse(400, "Week must be at least 1"));
}
var numberOfWeeks = ISOWeek.GetWeeksInYear(model.Year);
// Check if week is more than number of weeks in given year
if (model.Week > numberOfWeeks)
{
return(new BookingResponse(400, "Week must be at most " + numberOfWeeks));
}
// Calculate from and to dates for use in query
var centralEuropean = TimeZoneInfo.FindSystemTimeZoneById("Central European Standard Time");
var now = TimeZoneInfo.ConvertTime(DateTime.Now, centralEuropean);
var startOfWeek = ISOWeek.ToDateTime(model.Year, model.Week, DayOfWeek.Monday);
var from = now > startOfWeek ? now : startOfWeek;
var nextWeek = model.Week == numberOfWeeks ? 1 : model.Week + 1;
var newYear = model.Week == numberOfWeeks ? model.Year + 1 : model.Year;
var to = ISOWeek.ToDateTime(newYear, nextWeek, DayOfWeek.Monday);
// Get bookings in given week from now
var bookings = activity.Bookings.Where(b => b.Start >= from && b.Start < to);
var openHours = activity.Close - activity.Open;
var times = new int[7][];
// Generate array with all bookings in a week
for (var i = 0; i < 7; i++)
{
times[i] = new int[openHours];
for (var j = 0; j < openHours; j++)
{
var dateTime = startOfWeek.AddDays(i).AddHours(activity.Open + j);
if (now > dateTime)
{
times[i][j] = 2;
}
}
}
// Go through bookings and set times as booked
foreach (var booking in bookings)
{
var current = booking.Start;
while (current < booking.End)
{
var day = GetDayOfWeek(current.DayOfWeek);
var hour = current.Hour - activity.Open;
if (times[day][hour] != 2)
{
times[day][hour] = 1;
}
current = current.AddHours(1);
}
}
return(new BookingResponse(times));
}
