public async Task <Availability> AddUnavailabilityEntireDay(int employeeId, DateTime date, string reason)
{
if (date < DateTime.Now)
{
throw new DateHasPassedException();
}
var employee = _db.Employees.FirstOrDefault(e => e.Id == employeeId);
var availability = new Availability
{
IsAvailable = false,
Employee = employee,
StartTime = new DateTime(date.Year, date.Month, date.Day, 0, 0, 0),
EndTime = new DateTime(date.Year, date.Month, date.Day, 23, 59, 59),
Reason = reason,
EventTitle = "Niet beschikbaar"
};
if (!availability.Validate())
{
throw new InvalidDataException();
}
_db.PlannedEvents.Add(availability);
await _db.SaveChangesAsync();
return(availability);
}
public async Task <Availability> AddAbsence(int employeeId, string reason, DateTime?endTime)
{
if (endTime < DateTime.Now)
{
throw new DateHasPassedException();
}
var employee = _db.Employees.Include(e => e.Address).FirstOrDefault(e => e.Id == employeeId);
var absence = new Availability()
{
IsAvailable = false,
Employee = employee,
EndTime = endTime,
Reason = reason,
StartTime = DateTime.Now,
EventTitle = "Afwezig wegens ziekte"
};
if (!absence.Validate())
{
throw new InvalidDataException();
}
_db.PlannedEvents.Add(absence);
await _db.SaveChangesAsync();
return(absence);
}
public async Task <Address> SaveAddress(Address address)
{
if (!address.Validate())
{
throw new InvalidAddressException();
}
Address existing = await _db.Addresses.FirstOrDefaultAsync(a => a.Latitude == address.Latitude && a.Longitude == address.Longitude);
if (existing != null)
{
return(existing);
}
_db.Addresses.Add(address);
await _db.SaveChangesAsync();
return(address);
}
public async Task <PlannedInspection> CreatePlannedInspection(
int festivalId,
int questionnaireId,
DateTime startTime,
DateTime endTime,
string eventTitle,
int employeeId
)
{
var existing = _db.PlannedInspections
.FirstOrDefault(x =>
x.Questionnaire.Id == questionnaireId && x.Festival.Id == festivalId &&
x.Employee.Id == employeeId && x.StartTime.Equals(startTime) && x.IsCancelled == null);
if (existing != null)
{
throw new EntityExistsException();
}
var plannedInspection = new PlannedInspection
{
Festival = _db.Festivals.FirstOrDefault(x => x.Id == festivalId),
Questionnaire = _db.Questionnaires.FirstOrDefault(x => x.Id == questionnaireId),
Employee = _db.Employees.FirstOrDefault(x => x.Id == employeeId),
StartTime = startTime,
EndTime = endTime,
EventTitle = eventTitle
};
if (!plannedInspection.Validate())
{
throw new InvalidDataException();
}
_db.PlannedInspections.Add(plannedInspection);
await _db.SaveChangesAsync();
return(null);
}
public async Task ChangePassword(string username, string password, string newPassword)
{
var account = _db.Accounts.FirstOrDefault(x => x.Username == username);
if (account == null || !BCrypt.Net.BCrypt.Verify(password, account.Password))
{
throw new AuthenticationException("Username or password are incorrect");
}
account.Password = BCrypt.Net.BCrypt.HashPassword(newPassword);
await _db.SaveChangesAsync();
}
public async Task <Festival> CreateFestival(Festival festival, int customerId)
{
festival.Customer = await _db.Customers.FirstOrDefaultAsync(c => c.Id == customerId);
if (festival.OpeningHours.StartDate > festival.OpeningHours.EndDate ||
festival.OpeningHours.StartDate == festival.OpeningHours.EndDate &&
festival.OpeningHours.StartTime > festival.OpeningHours.EndTime)
{
throw new EndDateEarlierThanStartDateException();
}
if (!festival.Validate() || !festival.OpeningHours.Validate())
{
throw new InvalidDataException();
}
festival.Address = await _addressService.SaveAddress(festival.Address);
_db.Festivals.Add(festival);
await _db.SaveChangesAsync();
return(festival);
}
public async Task <double> CalculateDistance(Address origin, Address destination)
{
var existing = await _db.DistanceResults
.FirstOrDefaultAsync(x => x.Origin.Id == origin.Id && x.Destination.Id == destination.Id);
if (existing != null)
{
return(existing.Distance);
}
var request = await _client.GetAsync(
"distancematrix/json?units=metric" +
$"&origins={origin.Latitude.ToString(CultureInfo.InvariantCulture).Replace(",", ".")},{origin.Longitude.ToString(CultureInfo.InvariantCulture).Replace(",", ".")}" +
$"&destinations={destination.Latitude.ToString(CultureInfo.InvariantCulture).Replace(",", ".")},{destination.Longitude.ToString(CultureInfo.InvariantCulture).Replace(",", ".")}" +
$"&language=nl&key={_apiKey}");
var result =
JsonConvert.DeserializeObject <DistanceMatrixResponse>(await request.Content.ReadAsStringAsync());
if (!result.Status.Equals(GoogleStatusCodes.Ok))
{
throw new GoogleMapsApiException();
}
var distanceResult = new DistanceResult
{
Origin = await _db.Addresses.FirstOrDefaultAsync(a => a.Id == origin.Id),
Destination = await _db.Addresses.FirstOrDefaultAsync(a => a.Id == destination.Id),
Distance = Math.Round((double)result.Rows[0].Elements[0].Distance.DistanceValue / 1000, 2)
};
_db.DistanceResults.Add(distanceResult);
await _db.SaveChangesAsync();
return(distanceResult.Distance);
}
private async Task <int> SaveChangesAsync() => await _db.SaveChangesAsync();
public async Task <int> SaveChangesAsync()
{
return(await _db.SaveChangesAsync());
}
