public void RemoveReservationLijn(ReservatieLijn reservatieLijn, IReservatieRepository reservatieRepository)
{
if (reservatieLijn == null)
{
throw new ArgumentException("De reservatielijn is niet beschikbaar of mogelijk al verwijderd.");
}
if (!Reservaties.Contains(reservatieLijn.Reservatie))
{
throw new ArgumentException("De reservatielijn is niet beschikbaar.");
}
if (!reservatieLijn.Reservatie.ReservatieLijnen.Contains(reservatieLijn))
{
throw new ArgumentException("De reservatielijn is al verwijderd geweest.");
}
if (reservatieLijn.Reservatie.Opgehaald)
{
throw new ArgumentException("De reservatie is al opgehaald. Je kan geen wijzigingen meer aanbrengen.");
}
Reservatie r = reservatieLijn.Reservatie;
reservatieLijn.Reservatie.ReservatieLijnen.Remove(reservatieLijn);
reservatieRepository.RemoveReservationLine(reservatieLijn);
// Verwijder de volledige reservatie wanneer er geen reservatielijnen meer zijn.
if (r.ReservatieLijnen.Count == 0)
{
Reservaties.Remove(r);
reservatieRepository.Delete(r);
}
}
public override void VoegReservatieToe(Dictionary <Product, int> map, DateTime startDate, DateTime eindDate, Email[] email, bool[] dagen = null)
{
EmailService service = new EmailService();
Reservatie r = new Reservatie
{
StartDatum = startDate,
EindDatum = eindDate,
ReservatieStatus = ReservatieStatus.Gereserveerd,
ReservatieUser = this,
AanmaakDatum = DateTime.Now
};
foreach (KeyValuePair <Product, int> entry in map)
{
if (entry.Value != 0)
{
if (entry.Value > entry.Key.GeefAantalReserveerbaarInPeriode(startDate, eindDate))
{
throw new ArgumentOutOfRangeException("Er zijn niet genoeg stuks beschikbaar van " + entry.Key.Artikelnaam);
}
else if (entry.Value < 0)
{
throw new ArgumentOutOfRangeException("U kan geen negatieve waarde toekennen aan " + entry.Key.Artikelnaam);
}
r.VoegReservatieLijnToe(entry.Key, entry.Value);
}
}
Reservaties.Add(r);
service.VerzendEmail(r, this, email[0]);
}
public void AddReservation(Dictionary <Materiaal, int> teReserverenMaterialen,
DateTime ophaalDatum, DateTime indienDatum, DateTime today)
{
if (teReserverenMaterialen == null || teReserverenMaterialen.Count == 0)
{
throw new ArgumentException("Er moet ten minste 1 materiaal gereserveerd worden.");
}
if (today > ophaalDatum)
{
throw new ArgumentException("De ophaaldatum moet na vandaag zijn.");
}
Reservatie reservatie = new Reservatie(this, ophaalDatum, indienDatum);
reservatie.ReservatieLijnen = new List <ReservatieLijn>();
foreach (KeyValuePair <Materiaal, int> entry in teReserverenMaterialen)
{
Materiaal mat = entry.Key;
int amount = entry.Value;
long availableAmount = GetAmountAvailableForReservation(mat, ophaalDatum, indienDatum);
if (amount > availableAmount)
{
throw new ArgumentException(string.Format("Het materiaal {0} heeft nog maar {1} exemplaren beschikbaar.", mat.Name, availableAmount));
}
reservatie.AddReservationLine(mat, amount, ophaalDatum, indienDatum);
}
if (reservatie.ReservatieLijnen.Count == 0)
{
throw new ArgumentException("Een reservatie moet minstens één materiaal bevatten.");
}
Reservaties.Add(reservatie);
}
public Dictionary <DateTime, int[]> MaakLijstReservatieDataSpecifiekeDagen(DateTime[] dagen)
{
Dictionary <DateTime, int[]> reservatieMap = new Dictionary <DateTime, int[]>();
//De reservaties overlopen en reservatieDataDTO objecten met juiste waarden maken.
foreach (var r in Reservaties.Where(r => !(r.ReservatieState is Overruled) && r.Gebruiker is Lector).OrderBy(r => r.StartDatum))
{
IList <DateTime> gemeenschappelijkeDagen = r.GeblokkeerdeDagen.Select(g => g.Datum).Intersect(dagen).ToList();
if (gemeenschappelijkeDagen.Any())
{
foreach (var dag in gemeenschappelijkeDagen)
{
reservatieMap = UpdateReservatieMap(reservatieMap, dag, r.AantalGereserveerd);
}
}
}
var dagenZonderReservaties = dagen.Where(dag => !Reservaties.Any(r => r.GeblokkeerdeDagen.Select(d => d.Datum).Contains(dag)));
foreach (var dag in dagenZonderReservaties)
{
reservatieMap = UpdateReservatieMap(reservatieMap, dag, 0);
}
return(reservatieMap);
}
protected override void VoegReservatieToe(Materiaal materiaal, int aantal, string startdatum, string[] dagen = null)
{
Reservatie reservatie = MaakReservatieObject(this, materiaal, startdatum, aantal);
materiaal.AddReservatie(reservatie);
Reservaties.Add(reservatie);
}
public int GeefAantalBeschikbaarVoorBlokkering()
{
int aantal = AantalInCatalogus -
Reservaties.Where(r => r.ReservatieState is Gereserveerd || r.ReservatieState is Geblokkeerd || r.ReservatieState is Opgehaald)
.Sum(r => r.AantalGereserveerd);
return(aantal <= 0 ? 0 : aantal);
}
public override void VoegReservatieToe(Dictionary <Product, int> map, DateTime van, DateTime tot, Email[] email, bool[] dagen)
{
EmailService emailService = new EmailService();
Blokkering b = new Blokkering
{
StartDatum = van,
EindDatum = tot,
ReservatieUser = this,
ReservatieStatus = ReservatieStatus.Geblokkeerd,
AanmaakDatum = DateTime.Now,
};
int i = 0;
foreach (KeyValuePair <Product, int> entry in map)
{
if (entry.Value != 0)
{
if (entry.Value > entry.Key.AantalInCatalogus)
{
throw new ArgumentOutOfRangeException("Er zijn niet genoeg stuks beschikbaar van " + entry.Key.Artikelnaam);
}
if (entry.Value < 0)
{
throw new ArgumentOutOfRangeException("U kan geen negatieve waarde toekennen aan " + entry.Key.Artikelnaam);
}
if (dagen == null || dagen.All(l => !l))
{
throw new ArgumentNullException("Selecteer 1 of meerdere dagen voor " + entry.Key.Artikelnaam);
}
int aantal = entry.Key.GeefAantalReserveerbaarInPeriode(van, tot);
if (aantal < entry.Value)
{
entry.Key.WijzigReservatieAantal(entry.Value - aantal)
.ForEach(s => addStudenten(s));
}
bool[] dagenProduct = new bool[5];
Array.Copy(dagen, i, dagenProduct, 0, 5);
b.VoegReservatieLijnToe(entry.Key, entry.Value, dagenProduct);
}
i += 5;
}
Reservaties.Add(b);
emailService.VerzendEmail(b, this, email[0]);
studenten.Reverse();
ApplicationUser[] array = studenten.ToArray();
for (int j = 0; j < teller; j++)
{
if (j == 0)//Wijzigen
{
emailService.VerzendEmail(b, array[j], email[2]);
}
else//anuleren
{
emailService.VerzendEmail(b, array[j], email[1]);
}
}
}
public Reservatie RemoveReservation(Reservatie reservatie)
{
if (reservatie == null)
{
throw new ArgumentException("De reservatie is niet beschikbaar of mogelijk al verwijderd.");
}
if (!Reservaties.Contains(reservatie))
{
throw new ArgumentException("De reservatie is al verwijderd geweest.");
}
if (reservatie.Opgehaald)
{
throw new ArgumentException("Een reservatie die is al is opgehaald kan niet geannnuleerd worden.");
}
Reservaties.Remove(reservatie);
return(reservatie);
}
public int GeefAantalPerStatus(ReservatieState status, DateTime startDatum, DateTime eindDatum)
{
if (status is Geblokkeerd)
{
int aantal =
Reservaties.Where(
r => r.KanOverschrijvenMetReservatie(startDatum, eindDatum) && r.ReservatieState is Geblokkeerd)
.Sum(r => r.AantalGereserveerd);
return(aantal > AantalInCatalogus ? AantalInCatalogus : aantal);
}
if (status is Gereserveerd)
{
return(Reservaties.Where(r => r.StartDatum.Equals(startDatum) && r.ReservatieState is Gereserveerd).Sum(r => r.AantalGereserveerd));
}
return(0);
}
public Dictionary <DateTime, int[]> MaakLijstReservatieDataInRange(DateTime startDatumFilter, DateTime eindDatumFilter)
{
Dictionary <DateTime, int[]> reservatieMap = new Dictionary <DateTime, int[]>();
//De reservaties overlopen en reservatieDataDTO objecten met juiste waarden maken.
foreach (var r in Reservaties.Where(r => !(r.ReservatieState is Overruled)).OrderBy(r => r.StartDatum))
{
if (r.StartDatum >= startDatumFilter && r.StartDatum <= eindDatumFilter)
{
reservatieMap = UpdateReservatieMap(reservatieMap, r.StartDatum, r.AantalGereserveerd);
}
}
//Voor de data waar geen reservaties zijn worden reservatieDataDTO objecten met standaardWaarden gemaakt.
while (startDatumFilter <= eindDatumFilter)
{
reservatieMap = UpdateReservatieMap(reservatieMap, startDatumFilter, 0);
startDatumFilter = startDatumFilter.AddDays(7);
}
return(reservatieMap);
}
public int GeefAantalBeschikbaar(DateTime startDatum, DateTime eindDatum, IList <DateTime> dagen, Gebruiker gebruiker)
{
int aantal = AantalInCatalogus;
if (gebruiker is Lector && dagen != null)
{
foreach (var dag in dagen)
{
IEnumerable <Reservatie> overschijvendeReservaties = Reservaties.Where(r => r.GeblokkeerdeDagen.Select(d => d.Datum).Contains(dag)).ToList();
int aantalGereserveerd = overschijvendeReservaties.Sum(r => r.AantalGereserveerd);
aantal = Math.Min(aantal, AantalInCatalogus - aantalGereserveerd);
}
}
else if (gebruiker is Student)
{
aantal = AantalInCatalogus -
Reservaties.Where(r => r.KanOverschrijvenMetReservatie(startDatum, eindDatum) &&
(r.ReservatieState is Geblokkeerd || r.ReservatieState is Gereserveerd))
.Sum(r => r.AantalGereserveerd);
}
return(aantal <= 0 ? 0 : aantal);
}
public int GeefAantalReservatiesVoorKlantInJaar(Klant klant, int jaar)
{
return(Reservaties.Where(r => r.Klant == klant && r.StartMoment.Year == jaar).Count());
}
public List <Reservatie> VindReservatiesVoorKlantNummerEnDatum(int klantNummer, DateTime datum)
{
return(Reservaties.Include(r => r.Limousine).Include(r => r.Klant).ThenInclude(k => k.Categorie).ThenInclude(c => c.StaffelKorting).Where(r => r.StartMoment.Date == datum.Date && r.Klant.KlantNummer == klantNummer).ToList());
}
public List <Reservatie> VindReservatiesVoorKlantNaamEnDatum(string klantNaam, DateTime datum)
{
return(Reservaties.Include(r => r.Limousine).Include(r => r.Klant).ThenInclude(k => k.Categorie).ThenInclude(c => c.StaffelKorting).Where(r => r.StartMoment.Date == datum.Date && r.Klant.Naam.Contains(klantNaam)).ToList());
}
public List <Reservatie> VindReservatiesVoorKlantNummer(int klantNummer)
{
return(Reservaties.Include(r => r.Limousine).Include(r => r.Klant).ThenInclude(k => k.Categorie).ThenInclude(c => c.StaffelKorting).Where(r => r.Klant.KlantNummer == klantNummer).ToList());
}
public List <Reservatie> VindReservatiesVoorKlantNaam(string klantNaam)
{
return(Reservaties.Include(r => r.Limousine).Include(r => r.Klant).ThenInclude(k => k.Categorie).ThenInclude(c => c.StaffelKorting).Where(r => r.Klant.Naam.Contains(klantNaam)).ToList());
}
public Reservatie VindReservatieVoorReservatieNummer(int reservatieNummer)
{
return(Reservaties.Find(reservatieNummer));
}
public void AddReservatie(Reservatie reservatie)
{
Reservaties.Add(reservatie);
}
public void VoegReservatieToe(Reservatie reservatie)
{
Reservaties.Add(reservatie);
SaveChanges();
}
public ICollection <Reservatie> GeeftReservatiesVanEenBepaaldeTijd(DateTime start)
{
return(Reservaties.Where(r => r.StartDatum <= start && (!(r.ReservatieState is Opgehaald || r.ReservatieState is Overruled))).ToList());
}
