public void LoadFromDatabaseTest()
{
var repository = new LiteClockWorkRepository(_options);
var worker = new ClockWorker("Mustermann", "Max", new DateTime(1970, 5, 10));
var calendar = new ClockWorkUnitCollection(
worker,
new ClockWorkUnit(new DateTime(2018, 10, 1, 7, 38, 0), new DateTime(2018, 10, 1, 16, 12, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 2, 7, 33, 0), new DateTime(2018, 10, 2, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 4, 7, 35, 0), new DateTime(2018, 10, 4, 17, 7, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 5, 7, 36, 0), new DateTime(2018, 10, 5, 17, 5, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 8, 6, 58, 0), new DateTime(2018, 10, 8, 15, 35, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 9, 7, 33, 0), new DateTime(2018, 10, 9, 17, 1, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 10, 7, 35, 0), new DateTime(2018, 10, 10, 21, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 11, 8, 30, 0), new DateTime(2018, 10, 11, 21, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 12, 7, 35, 0), new DateTime(2018, 10, 12, 16, 45, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 15, 7, 42, 0), new DateTime(2018, 10, 15, 17, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 16, 7, 38, 0), new DateTime(2018, 10, 16, 15, 42, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 17, 7, 33, 0), new DateTime(2018, 10, 17, 17, 8, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 18, 7, 34, 0), new DateTime(2018, 10, 18, 17, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 19, 7, 35, 0), new DateTime(2018, 10, 19, 17, 11, 0))
);
repository.Save(calendar);
repository = new LiteClockWorkRepository(_options);
var loadedCalendar = repository.LoadCalendar(calendar.Worker.Id);
Assert.False(ReferenceEquals(calendar, loadedCalendar));
Assert.Equal(calendar.Worker, loadedCalendar.Worker);
Assert.Equal(calendar, loadedCalendar);
}
public void ExceptionTest()
{
var calendar = new ClockWorkUnitCollection(Worker, new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)));
Assert.Throws <ArgumentNullException>(() => calendar.Add(null));
Assert.Throws <ArgumentNullException>(() => calendar.Remove(null));
}
public void AddOverlapTest()
{
var calendar = new ClockWorkUnitCollection(Worker, new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)))
{
new ClockWorkUnit(DateTime.Today.AddHours(4), DateTime.Today.AddHours(5))
};
Assert.Equal(2, calendar.Count);
calendar.Add(new ClockWorkUnit(DateTime.Today.AddHours(7.5), DateTime.Today.AddHours(8.5)));
Assert.Equal(2, calendar.Count);
Assert.Equal(7.5, calendar.Last().Start.TimeOfDay.TotalHours);
Assert.Equal(17, calendar.Last().End.TimeOfDay.TotalHours);
calendar.Add(new ClockWorkUnit(DateTime.Today.AddHours(16.5), DateTime.Today.AddHours(17.5)));
Assert.Equal(2, calendar.Count);
Assert.Equal(7.5, calendar.Last().Start.TimeOfDay.TotalHours);
Assert.Equal(17.5, calendar.Last().End.TimeOfDay.TotalHours);
calendar.Add(new ClockWorkUnit(DateTime.Today.AddHours(7), DateTime.Today.AddHours(18)));
Assert.Equal(2, calendar.Count);
Assert.Equal(7, calendar.Last().Start.TimeOfDay.TotalHours);
Assert.Equal(18, calendar.Last().End.TimeOfDay.TotalHours);
calendar.Add(new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)));
Assert.Equal(2, calendar.Count);
Assert.Equal(7, calendar.Last().Start.TimeOfDay.TotalHours);
Assert.Equal(18, calendar.Last().End.TimeOfDay.TotalHours);
}
public void Save(ClockWorkUnitCollection calendar)
{
var existingCalender = _loadedCollections.SingleOrDefault(p => p.Worker.Equals(calendar.Worker));
if (existingCalender != null)
{
_loadedCollections.Remove(existingCalender);
}
_loadedCollections.Add(calendar);
using (var db = GetDatabase(_options))
{
var workers = db.Workers;
var units = db.Units;
var foundWorker = workers.FindOne(p => p.Id == calendar.Worker.Id);
if (foundWorker == null)
{
Save(calendar.Worker);
foundWorker = Worker.FromBusinessModel(calendar.Worker);
}
units.EnsureIndex(p => p.Start);
units.EnsureIndex(p => p.End);
units.Delete(p => p.Start >= calendar.First().Start.Date&& p.End < calendar.Last().End.Date.AddDays(1) && p.Worker.Id == foundWorker.Id);
units.InsertBulk(calendar.Select(p => Unit.FromBusinessModel(p, foundWorker)));
}
}
public void ComplexText()
{
var calendar = new ClockWorkUnitCollection(
new ClockWorker("Mustermann", "Max", new DateTime(1976, 4, 3)),
new ClockWorkUnit(new DateTime(2018, 10, 8, 7, 36, 0), new DateTime(2018, 10, 8, 15, 32, 0)).PauseFor(30), //-00:40:00
new ClockWorkUnit(new DateTime(2018, 10, 9, 7, 32, 0), new DateTime(2018, 10, 9, 17, 38, 0)).PauseFor(30), //+01:05:00
new ClockWorkUnit(new DateTime(2018, 10, 10, 7, 35, 0), new DateTime(2018, 10, 10, 21, 30, 0)).PauseFor(30).PauseFor(15).PauseFor(15), //+02:00:00
new ClockWorkUnit(new DateTime(2018, 10, 11, 8, 0, 0), new DateTime(2018, 10, 11, 21, 0, 0)).PauseFor(60), //+02:00:00
new ClockWorkUnit(new DateTime(2018, 10, 12, 7, 38, 0), new DateTime(2018, 10, 12, 17, 1, 0)).PauseFor(30) //+00:50:00
);
Assert.Equal("08.10.2018 07:36 - 08.10.2018 15:32 (Pause: 00:30)", calendar.First().ToString());
IEffectiveWorkingTimeCalculator calculator = new StsWorkCalculator();
var calculationResult = calculator.Calculate(calendar);
Assert.Equal(TimeSpan.FromHours(45.25), calculationResult.CalculatedWorkedHours);
Assert.True(calculationResult.ExactWorkedHours > calculationResult.CalculatedWorkedHours);
_output.WriteLine($"{calculationResult.CalculatedWorkedHours:g} ({calculationResult.ExactWorkedHours:g})");
var balance = calculator.GetBalance(calendar, new DateTime(2018, 10, 10, 0, 0, 0));
Assert.Equal(TimeSpan.FromMinutes(985), balance.CalculatedWorkedHours);
}
public ClockWorkUnitCollection LoadCalendar(int workerId)
{
var loadedCalendar = _loadedCollections.FirstOrDefault(p => p.Worker.Id == workerId);
if (loadedCalendar != null)
{
return(loadedCalendar);
}
using (var db = GetDatabase(_options))
{
var units = db.Units;
var query = units
.Include(p => p.Worker)
.Find(p => p.Worker.Id == workerId).ToArray();
if (!query.Any())
{
return(null);
}
loadedCalendar = new ClockWorkUnitCollection(query[0].Worker.ToBusinessModel(), query.Select(p => p.ToBusinessModel()).ToArray());
_loadedCollections.Add(loadedCalendar);
return(loadedCalendar);
}
}
public void CalendarTest()
{
var repository = new LiteClockWorkRepository(_options);
var worker = new ClockWorker("Mustermann", "Max", new DateTime(1970, 5, 10));
var calendar = new ClockWorkUnitCollection(
worker,
new ClockWorkUnit(new DateTime(2018, 10, 1, 7, 38, 0), new DateTime(2018, 10, 1, 16, 12, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 2, 7, 33, 0), new DateTime(2018, 10, 2, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 4, 7, 35, 0), new DateTime(2018, 10, 4, 17, 7, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 5, 7, 36, 0), new DateTime(2018, 10, 5, 17, 5, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 8, 6, 58, 0), new DateTime(2018, 10, 8, 15, 35, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 9, 7, 33, 0), new DateTime(2018, 10, 9, 17, 1, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 10, 7, 35, 0), new DateTime(2018, 10, 10, 21, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 11, 8, 30, 0), new DateTime(2018, 10, 11, 21, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 12, 7, 35, 0), new DateTime(2018, 10, 12, 16, 45, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 15, 7, 42, 0), new DateTime(2018, 10, 15, 17, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 16, 7, 38, 0), new DateTime(2018, 10, 16, 15, 42, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 17, 7, 33, 0), new DateTime(2018, 10, 17, 17, 8, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 18, 7, 34, 0), new DateTime(2018, 10, 18, 17, 0, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 19, 7, 35, 0), new DateTime(2018, 10, 19, 17, 11, 0))
);
repository.Save(calendar);
repository.Save(calendar); //loads from cache, test for database loading needed
var savedCalendar = repository.LoadCalendar(worker.Id);
Assert.Equal(calendar, savedCalendar);
}
public void CreateTest()
{
var myCalendar = new ClockWorkUnitCollection(Worker);
Assert.Equal(Worker, myCalendar.Worker);
Assert.Empty(myCalendar);
Assert.False(myCalendar.IsReadOnly);
}
public void CreateEmptyCollectionTest()
{
var calendar = new ClockWorkUnitCollection(Worker);
Assert.Empty(calendar);
calendar = new ClockWorkUnitCollection(Worker, null);
Assert.Empty(calendar);
calendar.Add(new ClockWorkUnit(DateTime.Today, DateTime.Now));
Assert.NotEmpty(calendar);
}
public void AddMultipleDaysUnitTest()
{
var start = new DateTime(2018, 10, 1);
var calendar = new ClockWorkUnitCollection(Worker, new ClockWorkUnit(start.AddHours(8), start.AddHours(17)))
{
new ClockWorkUnit(start.AddHours(16), start.AddHours(100))
};
Assert.Equal(5, calendar.Count);
}
public void ExoticTest()
{
var calendar = new ClockWorkUnitCollection(
new ClockWorker("Mustermann", "Max", new DateTime(1976, 4, 3)),
new ClockWorkUnit(new DateTime(2018, 10, 1, 8, 2, 0), new DateTime(2018, 10, 1, 8, 5, 0)));
IEffectiveWorkingTimeCalculator calculator = new StsWorkCalculator();
var calculationResult = calculator.Calculate(calendar);
Assert.Equal(TimeSpan.Zero, calculationResult.CalculatedWorkedHours);
}
public void CreateStandardCalendarTest()
{
var myCalendar = new ClockWorkUnitCollection(
Worker,
new ClockWorkUnit(DateTime.Today.AddDays(-3).AddHours(8), DateTime.Today.AddDays(-3).AddHours(17)),
new ClockWorkUnit(DateTime.Today.AddDays(-2).AddHours(8), DateTime.Today.AddDays(-2).AddHours(17)),
new ClockWorkUnit(DateTime.Today.AddDays(-1).AddHours(8), DateTime.Today.AddDays(-1).AddHours(17)),
new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17))
);
Assert.Equal(4, myCalendar.Count);
}
public void Test()
{
var unit = new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)).PauseFor(30);
var worker = new ClockWorker("Mustermann", "Max", DateTime.Today.AddYears(-21));
var calendar = new ClockWorkUnitCollection(worker, unit);
IEffectiveWorkingTimeCalculator calculator = new StsWorkCalculator();
var calculationResult = calculator.Calculate(calendar);
Assert.Equal(TimeSpan.FromHours(8.5), calculationResult.CalculatedWorkedHours);
Assert.Equal(TimeSpan.FromHours(8.5), calculationResult.ExactWorkedHours);
calendar.Add(new ClockWorkUnit(new DateTime(2018, 10, 1, 7, 58, 10), new DateTime(2018, 10, 1, 16, 56, 20)));
calculationResult = calculator.Calculate(calendar);
Assert.Equal(TimeSpan.FromMinutes(1010), calculationResult.CalculatedWorkedHours);
Assert.NotEqual(calculationResult.CalculatedWorkedHours, calculationResult.ExactWorkedHours);
}
public Task <IActionResult> AddUnitOfWork(int id, [FromBody] ClockWorkUnit unit)
{
var calender = _repository.LoadCalendar(id);
if (calender == null)
{
var worker = _repository.LoadWorker(id);
if (worker == null)
{
return(Task.FromResult((IActionResult)NotFound()));
}
calender = new ClockWorkUnitCollection(_repository.LoadWorker(id));
}
calender.Add(unit);
_repository.Save(calender);
return(Task.FromResult((IActionResult)Ok()));
}
public void CollectionTest()
{
var calendar = new ClockWorkUnitCollection(Worker, new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)));
calendar.Clear();
Assert.Empty(calendar);
calendar.Add(new ClockWorkUnit(DateTime.Today.AddHours(8), DateTime.Today.AddHours(17)));
Assert.Contains(calendar.First(), calendar);
var unitList = new ClockWorkUnit[10];
calendar.CopyTo(unitList, 1);
Assert.True(unitList.Skip(2).All(p => p == null));
Assert.Null(unitList.First());
Assert.Contains(unitList[1], calendar);
calendar.Remove(unitList[1]);
Assert.Empty(calendar);
}
public void Test()
{
var startDate = new DateTime(2018, 10, 26).Date;
var unit = new ClockWorkUnit(startDate.AddHours(8), startDate.AddHours(17));
var worker = new ClockWorker("Mustermann", "Max", startDate.AddYears(-21));
var calendar = new ClockWorkUnitCollection(worker, unit);
IEffectiveWorkingTimeCalculator calculator = new ExactWorkCalculator();
var calculationResult = calculator.Calculate(calendar);
Assert.Equal(TimeSpan.FromHours(9), calculationResult.CalculatedWorkedHours);
Assert.Equal(TimeSpan.FromHours(9), calculationResult.ExactWorkedHours);
var result = calculator.GetBalance(calendar, startDate.AddDays(1));
Assert.Equal(calculationResult.CalculatedWorkedHours, result.CalculatedWorkedHours);
Assert.Equal("26.10.2018, KW 43: +09:00/+08:00", calculationResult.Single().ToString());
}
public void RealDataTest()
{
var worker = new ClockWorker("Mustermann", "Max", new DateTime(1970, 5, 10));
var calendar = new ClockWorkUnitCollection(
worker,
new ClockWorkUnit(new DateTime(2018, 10, 01, 07, 38, 0), new DateTime(2018, 10, 01, 16, 12, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 02, 07, 33, 0), new DateTime(2018, 10, 02, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 04, 07, 35, 0), new DateTime(2018, 10, 04, 17, 07, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 05, 07, 36, 0), new DateTime(2018, 10, 05, 17, 05, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 08, 06, 58, 0), new DateTime(2018, 10, 08, 15, 35, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 09, 07, 33, 0), new DateTime(2018, 10, 09, 17, 01, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 10, 07, 35, 0), new DateTime(2018, 10, 10, 21, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 11, 08, 30, 0), new DateTime(2018, 10, 11, 21, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 12, 07, 35, 0), new DateTime(2018, 10, 12, 16, 45, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 15, 07, 42, 0), new DateTime(2018, 10, 15, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 16, 07, 38, 0), new DateTime(2018, 10, 16, 15, 42, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 17, 07, 33, 0), new DateTime(2018, 10, 17, 17, 08, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 18, 07, 34, 0), new DateTime(2018, 10, 18, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 19, 07, 35, 0), new DateTime(2018, 10, 19, 17, 11, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 22, 07, 38, 0), new DateTime(2018, 10, 22, 16, 12, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 23, 07, 45, 0), new DateTime(2018, 10, 23, 17, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 24, 00, 00, 0), new DateTime(2018, 10, 24, 00, 00, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 25, 07, 40, 0), new DateTime(2018, 10, 25, 16, 36, 0)),
new ClockWorkUnit(new DateTime(2018, 10, 26, 07, 32, 0), new DateTime(2018, 10, 26, 17, 02, 0))
);
IEffectiveWorkingTimeCalculator calculator = new StsWorkCalculator();
var calculationResult = calculator.Calculate(calendar);
string DisplayTime(TimeSpan ts)
{
return($"{(ts < TimeSpan.Zero ? "-" : "+")}{(int) Math.Abs(ts.TotalHours):D2}:{Math.Abs(ts.Minutes):D2}");
}
void LogResult(CalculationResultCollection r, Func <CalculationResult, string> getPrefix)
{
r.ToList().ForEach(p => _output.WriteLine("{0}: balance {1}", getPrefix(p), DisplayTime(p.Overtime)));
}
_output.WriteLine($"Calculated working time for calendar from {calendar.First().Start.Date:dd.MM.yyyy} to {calendar.Last().Start.Date:dd.MM.yyyy}");
_output.WriteLine($" Regular working hours: {DisplayTime(calculationResult.WorkingHours)}");
_output.WriteLine($" Hours accounted for: {DisplayTime(calculationResult.CalculatedWorkedHours)}");
_output.WriteLine($" Unaccounted time: {DisplayTime(calculationResult.ExactWorkedHours - calculationResult.CalculatedWorkedHours)}");
_output.WriteLine($" Accounted overtime: {DisplayTime(calculationResult.Overtime)}");
_output.WriteLine("".PadLeft(80, '='));
_output.WriteLine(string.Empty);
_output.WriteLine("Output by day:");
LogResult(calculationResult, p => p.Date.ToString("dd.MM.yyyy"));
_output.WriteLine("".PadLeft(80, '='));
Assert.Equal(19, calculationResult.Count);
Assert.Equal(calculationResult, calculationResult.GroupBy.Day);
var result = calculationResult.GroupBy.Week;
_output.WriteLine("Output by week:");
LogResult(result, p => "KW " + (1 + (p.Date.DayOfYear - 1) / 7));
_output.WriteLine("".PadLeft(80, '='));
Assert.Equal(4, result.Count);
result = calculationResult.GroupBy.Month;
_output.WriteLine("Output by month:");
LogResult(result, p => p.Date.ToString("MMMM", new CultureInfo("de-DE")));
_output.WriteLine("".PadLeft(80, '='));
Assert.Single(result);
result = calculationResult.GroupBy.Year;
_output.WriteLine("Output by year:");
LogResult(result, p => p.Date.Year.ToString(CultureInfo.InvariantCulture));
_output.WriteLine("".PadLeft(80, '='));
Assert.Single(result);
}
public CalculationResultCollection Calculate(ClockWorkUnitCollection units)
{
return(new CalculationResultCollection(units.Select(Calculate)));
}
public CalculationResult GetBalance(ClockWorkUnitCollection units, DateTime snapshot)
{
var result = new CalculationResultCollection(new ClockWorkUnitCollection(units.Worker, units.Where(p => p.End <= snapshot).ToArray()).Select(Calculate));
return(new CalculationResult(units.First().Start.Date, result.WorkingHours, result.ExactWorkedHours, result.CalculatedWorkedHours));
}