/// <summary>
/// Maakt een nieuwe afdeling voor een Chirogroep, zonder te persisteren
/// </summary>
/// <param name="groep">
/// Chirogroep waarvoor afdeling moet worden gemaakt, met daaraan gekoppeld
/// de bestaande afdelingen
/// </param>
/// <param name="naam">
/// Naam van de afdeling
/// </param>
/// <param name="afkorting">
/// Handige afkorting voor in schemaatjes
/// </param>
/// <returns>
/// De toegevoegde (maar nog niet gepersisteerde) afdeling
/// </returns>
/// <exception cref="GeenGavException">
/// Komt voor als de gebruiker geen GAV is voor de opgegeven <paramref name="groep"/>
/// </exception>
public Afdeling AfdelingToevoegen(ChiroGroep groep, string naam, string afkorting)
{
if (!_autorisatieMgr.IsGav(groep))
{
throw new GeenGavException(Resources.GeenGav);
}
// Controleren of de afdeling nog niet bestaat
var bestaand = from afd in groep.Afdeling
where string.Compare(afd.Afkorting, afkorting, true) == 0 ||
string.Compare(afd.Naam, naam, true) == 0
select afd;
if (bestaand.FirstOrDefault() != null)
{
// TODO (#507): Check op bestaande afdeling door DB
throw new BestaatAlException <Afdeling>(bestaand.FirstOrDefault());
}
var a = new Afdeling
{
Afkorting = afkorting,
Naam = naam
};
a.ChiroGroep = groep;
groep.Afdeling.Add(a);
return(a);
}
public void GroepDesactiverenTest()
{
// ARRANGE
var groep = new ChiroGroep {
Code = "TST/0001"
};
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Groep>())
.Returns(new DummyRepo <Groep>(new List <Groep> {
groep
}));
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <GapUpdater>();
target.GroepDesactiveren(groep.Code, DateTime.Now);
// ASSERT
Assert.IsNotNull(groep.StopDatum);
}
public void AdresGenotenZelfdeGroepTest()
{
// ARRANGE
var gelieerdePersoon1 = new GelieerdePersoon {
ID = 2, Persoon = new Persoon {
ID = 4
}
};
gelieerdePersoon1.Persoon.GelieerdePersoon.Add(gelieerdePersoon1);
var gelieerdePersoon2 = new GelieerdePersoon {
ID = 3, Persoon = new Persoon {
ID = 5
}
};
gelieerdePersoon2.Persoon.GelieerdePersoon.Add(gelieerdePersoon2);
var groep = new ChiroGroep
{
ID = 1,
GelieerdePersoon = new List <GelieerdePersoon> {
gelieerdePersoon1, gelieerdePersoon2
}
};
gelieerdePersoon1.Groep = groep;
gelieerdePersoon2.Groep = groep;
var adres = new BelgischAdres();
var persoonsAdres1 = new PersoonsAdres {
ID = 6, Persoon = gelieerdePersoon1.Persoon, Adres = adres
};
var persoonsAdres2 = new PersoonsAdres {
ID = 7, Persoon = gelieerdePersoon2.Persoon, Adres = adres
};
gelieerdePersoon1.Persoon.PersoonsAdres = new List <PersoonsAdres> {
persoonsAdres1
};
gelieerdePersoon2.Persoon.PersoonsAdres = new List <PersoonsAdres> {
persoonsAdres2
};
adres.PersoonsAdres = new List <PersoonsAdres> {
persoonsAdres1, persoonsAdres2
};
// ACT
var target = new GelieerdePersonenManager();
var result = target.AdresGenotenUitZelfdeGroep(gelieerdePersoon1);
// ASSERT
Assert.IsTrue(result.Contains(gelieerdePersoon1));
Assert.IsTrue(result.Contains(gelieerdePersoon2));
}
public void NietToegekendeVerplichteFunctie()
{
// ARRANGE
var g = new ChiroGroep();
// een (eigen) functie waarvan er precies 1 moet zijn
var f = new Functie
{
MinAantal = 1,
Type = LidType.Alles,
ID = 1,
IsNationaal = false,
Niveau = Niveau.Alles,
Groep = g,
};
// groepswerkjaar zonder leden
var gwj = new GroepsWerkJaar
{
Lid = new List <Lid>(),
Groep = g
};
// Maak een functiesmanager
var fm = Factory.Maak <FunctiesManager>();
// ACT
var problemen = fm.AantallenControleren(gwj, new[] { f });
// ASSERT
Assert.IsTrue(problemen.Any(prb => prb.ID == f.ID));
}
public void NieuwInschrijvenLidAdres()
{
// ARRANGE
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2014
};
var gelieerdePersoon = new GelieerdePersoon
{
Groep = groep,
ChiroLeefTijd = 0,
Persoon =
new Persoon
{
Geslacht = GeslachtsType.Vrouw,
GeboorteDatum = new DateTime(1994, 04, 23)
}
};
var target = Factory.Maak <LedenManager>();
// Assert
var ex = Assert.Throws <FoutNummerException>(() => target.NieuwInschrijven(new LidVoorstel
{
GelieerdePersoon = gelieerdePersoon,
GroepsWerkJaar = groepsWerkJaar,
AfdelingsJarenIrrelevant = false,
LeidingMaken = true
}, false));
Assert.AreEqual(FoutNummer.AdresOntbreekt, ex.FoutNummer);
}
public void FunctieLangerInGebruikGeforceerdVerwijderenTest()
{
// ARRANGE
// model
var groep = new ChiroGroep();
var vorigWerkJaar = new GroepsWerkJaar {
WerkJaar = 2011, Groep = groep, ID = 2
};
var ditWerkJaar = new GroepsWerkJaar {
WerkJaar = 2012, Groep = groep, ID = 3
};
groep.GroepsWerkJaar.Add(vorigWerkJaar);
groep.GroepsWerkJaar.Add(ditWerkJaar);
var functie = new Functie {
Groep = groep, ID = 1
};
groep.Functie.Add(functie);
var gelieerdePersoon = new GelieerdePersoon {
Groep = groep
};
groep.GelieerdePersoon.Add(gelieerdePersoon);
var leidingToen = new Leiding {
GelieerdePersoon = gelieerdePersoon, GroepsWerkJaar = vorigWerkJaar
};
var leidingNu = new Leiding {
GelieerdePersoon = gelieerdePersoon, GroepsWerkJaar = ditWerkJaar
};
vorigWerkJaar.Lid.Add(leidingToen);
ditWerkJaar.Lid.Add(leidingNu);
leidingToen.Functie.Add(functie);
leidingNu.Functie.Add(functie);
functie.Lid.Add(leidingToen);
functie.Lid.Add(leidingNu);
// ACT
var mgr = Factory.Maak <FunctiesManager>();
var result = mgr.Verwijderen(functie, true);
// ASSERT
// functie niet meer geldig
Assert.IsTrue(groep.Functie.Contains(functie));
Assert.AreEqual(result.WerkJaarTot, ditWerkJaar.WerkJaar - 1);
// enkel het lid van dit werkJaar blijft over
Assert.AreEqual(result.Lid.Count, 1);
}
public void PlaatsOpOnbekendAdresBewarenTest()
{
// ARRANGE
var groep = new ChiroGroep {
ID = 3
};
var bivak = new Uitstap {
ID = 1, GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
var land = new Land {
Naam = "Nederland"
};
// dependency injection voor data access
var dummyRepositoryProvider = new Mock <IRepositoryProvider>();
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Uitstap>())
.Returns(new DummyRepo <Uitstap>(new List <Uitstap> {
bivak
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Plaats>())
.Returns(new DummyRepo <Plaats>(new List <Plaats>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Adres>())
.Returns(new DummyRepo <Adres>(new List <Adres>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Land>())
.Returns(new DummyRepo <Land>(new List <Land> {
land
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <WoonPlaats>())
.Returns(new DummyRepo <WoonPlaats>(new List <WoonPlaats>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <StraatNaam>())
.Returns(new DummyRepo <StraatNaam>(new List <StraatNaam>()));
Factory.InstantieRegistreren(dummyRepositoryProvider.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.PlaatsBewaren(bivak.ID, "Warme Bivakplaats",
new AdresInfo
{
StraatNaamNaam = "Zonnestraat",
HuisNr = 8,
PostNr = 9876,
PostCode = "PF",
WoonPlaatsNaam = "Warmegem",
LandNaam = "Nederland"
});
// ASSERT
Assert.IsInstanceOf <BuitenLandsAdres>(bivak.Plaats.Adres);
}
public void InschrijvenLeidingZonderAfdelingTest()
{
// ARRANGE
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2012
};
var gelieerdePersoon = new GelieerdePersoon
{
Groep = groep,
ChiroLeefTijd = 0,
Persoon =
new Persoon
{
Geslacht = GeslachtsType.Vrouw,
GeboorteDatum = new DateTime(1990, 04, 23)
},
// verplichte velden voor inschrijving (#1786)
PersoonsAdres = new PersoonsAdres(),
Communicatie =
new List <CommunicatieVorm>
{
new CommunicatieVorm
{
CommunicatieType = new CommunicatieType {
ID = (int)CommunicatieTypeEnum.TelefoonNummer
}
},
new CommunicatieVorm
{
CommunicatieType = new CommunicatieType {
ID = (int)CommunicatieTypeEnum.Email
}
}
}
};
var target = Factory.Maak <LedenManager>();
// ACT
var actual =
target.NieuwInschrijven(new LidVoorstel
{
GroepsWerkJaar = groepsWerkJaar,
GelieerdePersoon = gelieerdePersoon,
AfdelingsJarenIrrelevant = false,
LeidingMaken = true
}, false) as Leiding;
// ASSERT
Assert.IsNotNull(actual);
Assert.AreEqual(0, actual.AfdelingsJaar.Count);
}
public void RechtenOpLidAndereGroepTest()
{
// ARRANGE
var ik = new Persoon {
AdNummer = 1234
};
var gp = new GelieerdePersoon {
Persoon = new Persoon()
};
var groep = new ChiroGroep
{
GebruikersRechtV2 = new[]
{
new GebruikersRechtV2
{
Persoon = ik,
VervalDatum = DateTime.Today.AddDays(1),
IedereenPermissies = Permissies.Lezen
}
},
GelieerdePersoon = new[]
{
gp
}
};
gp.Groep = groep;
var leiding = new Leiding
{
GelieerdePersoon = gp,
GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
// Zet mock op voor het opleveren van gebruikersnaam
var authenticatieManagerMock = new Mock <IAuthenticatieManager>();
authenticatieManagerMock.Setup(src => src.AdNummerGet()).Returns(ik.AdNummer);
Factory.InstantieRegistreren(authenticatieManagerMock.Object);
// ACT
var target = Factory.Maak <AutorisatieManager>();
var actual = target.PermissiesOphalen(leiding);
// ASSERT
Assert.IsTrue(actual.HasFlag(Permissies.Lezen));
}
public void JaarOvergangUitvoerenTest()
{
// ARRANGE
// Vrij veel voorbereiding voor een vrij flauwe test.
var ribbeloff = new OfficieleAfdeling {
ID = 1, LeefTijdTot = 7, LeefTijdVan = 6, Naam = "Ribbel"
};
var groep = new ChiroGroep {
ID = 10, GroepsWerkJaar = new List <GroepsWerkJaar>()
};
var gwj = new GroepsWerkJaar {
WerkJaar = 2010, Groep = groep
};
groep.GroepsWerkJaar.Add(gwj);
var afdjaar1 = new AfdelingsJaar {
ID = 1, GeboorteJaarVan = 2003, GeboorteJaarTot = 2004, OfficieleAfdeling = ribbeloff
};
var afd1 = new Afdeling {
ID = 2, AfdelingsJaar = new List <AfdelingsJaar> {
afdjaar1
}, ChiroGroep = groep
};
afdjaar1.Afdeling = afd1;
groep.Afdeling.Add(afd1);
gwj.AfdelingsJaar.Add(afdjaar1);
var newafdjaar = new AfdelingDetail {
AfdelingID = afd1.ID, AfdelingsJaarID = afdjaar1.ID, GeboorteJaarVan = DateTime.Today.Year - 10, GeboorteJaarTot = DateTime.Today.Year - 8, OfficieleAfdelingID = ribbeloff.ID, Geslacht = GeslachtsType.Gemengd
};
var officieleAfdelingenRepo = new DummyRepo <OfficieleAfdeling>(new[] { ribbeloff });
// ACT
var target = Factory.Maak <JaarOvergangManager>();
var teActiveren = new List <AfdelingsJaarDetail> {
newafdjaar
};
target.JaarOvergangUitvoeren(teActiveren, groep, officieleAfdelingenRepo);
// ASSERT
Assert.AreEqual(groep.GroepsWerkJaar.Count, 2);
Assert.AreEqual(groep.GroepsWerkJaar.OrderByDescending(gwjr => gwjr.WerkJaar).First().AfdelingsJaar.Count, 1);
}
public void AfdelingsJarenVoorstellenMvxGemengdTest()
{
// -- Arrange --
// Testsituatie opzetten
var ribbels = new OfficieleAfdeling
{
ID = (int)NationaleAfdeling.Ribbels,
LeefTijdVan = 6,
LeefTijdTot = 7
};
// Een Chirogroep met een oud groepswerkjaar.
var groep = new ChiroGroep();
var sloebers = new Afdeling {
ID = 1, ChiroGroep = groep
};
var oudGroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
};
groep.GroepsWerkJaar.Add(oudGroepsWerkJaar);
oudGroepsWerkJaar.AfdelingsJaar.Add(new AfdelingsJaar
{
Afdeling = sloebers,
GroepsWerkJaar = oudGroepsWerkJaar,
OfficieleAfdeling = ribbels,
// Geslacht uit de oude doos:
Geslacht = (GeslachtsType.Man | GeslachtsType.Vrouw)
});
// Dit jaar willen we een groep met 1 afdeling.
var afdelingen = new List <Afdeling> {
sloebers
};
const int NIEUW_WERKJAAR = 2012; // Jaartal is eigenlijk irrelevant voor deze test.
// -- Act --
var target = Factory.Maak <GroepsWerkJarenManager>();
var actual = target.AfdelingsJarenVoorstellen(groep, afdelingen, NIEUW_WERKJAAR, ribbels);
var afdelingsJaar = actual.FirstOrDefault();
// -- Assert --
Assert.IsNotNull(afdelingsJaar);
Assert.AreEqual(afdelingsJaar.Geslacht, GeslachtsType.Gemengd);
}
public void CategorieVerwijderenMetPersoonForceer()
{
// ARRANGE
#region testdata
var groep = new ChiroGroep();
var categorie = new Categorie
{
ID = 1,
Groep = groep
};
groep.Categorie.Add(categorie);
var gelieerdePersoon = new GelieerdePersoon {
Groep = groep
};
groep.GelieerdePersoon.Add(gelieerdePersoon);
categorie.GelieerdePersoon.Add(gelieerdePersoon);
gelieerdePersoon.Categorie.Add(categorie);
#endregion
#region dependency injection
var categorieenRepo = new DummyRepo <Categorie>(new List <Categorie> {
categorie
});
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Categorie>())
.Returns(categorieenRepo);
Factory.InstantieRegistreren(repositoryProviderMock.Object);
#endregion
// ACT
var groepenService = Factory.Maak <GroepenService>();
// Verwijder categorie door te forceren
groepenService.CategorieVerwijderen(categorie.ID, true);
// ASSERT
Assert.IsNull(categorieenRepo.ByID(categorie.ID)); // categorie weg
}
public void IsGavGelieerdePersoonTest()
{
// ARRANGE
// testgroep met gelieerde persoon; toegang met mijnLogin net vervallen.
const string mijnLogin = "******";
var gp = new GelieerdePersoon {
Persoon = new Persoon()
};
var groep = new ChiroGroep
{
GebruikersRechtV2 = new[]
{
new GebruikersRechtV2
{
Persoon = gp.Persoon,
VervalDatum = DateTime.Today // net vervallen
}
},
GelieerdePersoon = new[]
{
gp
}
};
gp.Groep = groep;
// Zet mock op voor het opleveren van gebruikersnaam
var authenticatieManagerMock = new Mock <IAuthenticatieManager>();
authenticatieManagerMock.Setup(src => src.GebruikersNaamGet()).Returns(mijnLogin);
Factory.InstantieRegistreren(authenticatieManagerMock.Object);
// ACT
var target = Factory.Maak <AutorisatieManager>();
var actual = target.IsGav(groep);
// ASSERT
Assert.IsFalse(actual);
}
public void GeenAansluitingenOudWerkjaarTest()
{
// Stel: het is juli 2016.
var datum = new DateTime(2016, 7, 15);
var groep = new ChiroGroep
{
GroepsWerkJaar = new List <GroepsWerkJaar>()
};
var gwj1 = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2016
};
// De groep heeft zijn jaarovergang al gedaan, en er bestaat dus een werkjaar 2017-2018.
var gwj2 = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2017
};
groep.GroepsWerkJaar.Add(gwj1);
groep.GroepsWerkJaar.Add(gwj2);
var lid = new Leiding
{
GroepsWerkJaar = gwj1,
EindeInstapPeriode = datum.AddDays(-5),
GelieerdePersoon = new GelieerdePersoon
{
Groep = groep,
Persoon = new Persoon()
}
};
lid.GelieerdePersoon.Persoon.GelieerdePersoon.Add(lid.GelieerdePersoon);
gwj1.Lid = new List <Lid> {
lid
};
var target = new LedenManager();
// Nu proberen we uit te zoeken welke leden er nog aangesloten moeten worden in 2016-2017.
var result = target.AanTeSluitenLedenOphalen(groep.GroepsWerkJaar.SelectMany(gwj => gwj.Lid).AsQueryable(),
2016, datum, null);
Assert.IsEmpty(result);
}
public void NieuwInschrijvenLeidingLeeftijd()
{
// ARRANGE
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep, WerkJaar = 2012
};
var gelieerdePersoon = new GelieerdePersoon
{
Groep = groep,
ChiroLeefTijd = 0,
Persoon =
new Persoon
{
Geslacht = GeslachtsType.Vrouw,
GeboorteDatum = new DateTime(2000, 04, 23) // wat jong om leiding te worden
}
};
var target = Factory.Maak <LedenManager>();
// ACT
try
{
target.NieuwInschrijven(new LidVoorstel
{
GelieerdePersoon = gelieerdePersoon,
GroepsWerkJaar = groepsWerkJaar,
AfdelingsJarenIrrelevant = false,
LeidingMaken = true
}, false);
}
catch (GapException)
{
// We verwachten weliswaar een exception, maar we verwachten ook
// dat het lid niet gemaakt is.
}
// ASSERT
Assert.AreEqual(0, gelieerdePersoon.Lid.Count);
}
public void AfdelingsJarenVoorstellenOfficieleAfdelingTest()
{
// -- Arrange --
// Testsituatie opzetten
var ribbels = new OfficieleAfdeling
{
ID = (int)NationaleAfdeling.Ribbels,
LeefTijdVan = 6,
LeefTijdTot = 7
};
// Een Chirogroep met een oud groepswerkjaar. Zonder afdelingen, why not.
var groep = new ChiroGroep
{
GroepsWerkJaar = new List <GroepsWerkJaar> {
new GroepsWerkJaar()
}
};
// Dit jaar willen we een groep met 1 afdeling.
var afdelingen = new List <Afdeling> {
new Afdeling {
ID = 1, ChiroGroep = groep
}
};
const int NIEUW_WERKJAAR = 2012; // Jaartal is eigenlijk irrelevant voor deze test.
// -- Act --
var target = Factory.Maak <GroepsWerkJarenManager>();
var actual = target.AfdelingsJarenVoorstellen(groep, afdelingen, NIEUW_WERKJAAR, ribbels);
var afdelingsJaar = actual.FirstOrDefault();
// -- Assert --
Assert.IsNotNull(afdelingsJaar);
Assert.IsNotNull(afdelingsJaar.OfficieleAfdeling);
}
public void AfdelingGroepsWerkJaarMismatch()
{
var groep1 = new ChiroGroep {
ID = 1
};
var groep2 = new ChiroGroep {
ID = 2
};
var gwj = new GroepsWerkJaar {
ID = 1, Groep = groep1
};
var a = new Afdeling {
ChiroGroep = groep2
};
var oa = new OfficieleAfdeling();
var target = Factory.Maak <IAfdelingsJaarManager>();
var ex = Assert.Throws <FoutNummerException>(() => target.Aanmaken(a, oa, gwj, 2001, 2002, GeslachtsType.Gemengd));
}
public void TweeKeerUniekeFunctieToekennenTestZelfdeLid()
{
// Arrange
// Genereer de situatie
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep
};
groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
groepsWerkJaar
};
var leider = new Leiding {
GroepsWerkJaar = groepsWerkJaar
};
var functie = new Functie
{
MaxAantal = 1,
Type = LidType.Alles,
IsNationaal = true,
Niveau = Niveau.Alles
};
var fm = Factory.Maak <FunctiesManager>();
// Act
fm.Toekennen(leider, new[] { functie });
fm.Toekennen(leider, new[] { functie });
// Assert
var problemen = fm.AantallenControleren(groepsWerkJaar, new[] { functie });
Assert.AreEqual(problemen.Count(), 0);
}
public void IsGavGroepVervallenTest()
{
// ARRANGE
// testgroep; toegang voor deze persoon net vervallen.
const int mijnAdNummer = 12345;
Groep groep = new ChiroGroep
{
GebruikersRechtV2 = new[]
{
new GebruikersRechtV2
{
Persoon = new Persoon {
AdNummer = mijnAdNummer
},
VervalDatum = DateTime.Today // net vervallen
}
}
};
// Zet mock op voor het opleveren van gebruikersnaam
var authenticatieManagerMock = new Mock <IAuthenticatieManager>();
authenticatieManagerMock.Setup(src => src.AdNummerGet()).Returns(mijnAdNummer);
Factory.InstantieRegistreren(authenticatieManagerMock.Object);
// ACT
var target = Factory.Maak <AutorisatieManager>();
var actual = target.IsGav(groep);
// ASSERT
Assert.IsFalse(actual);
}
public void GroepsRechtImpliceertAfdelingsRechtTest()
{
// ARRANGE
// testgroep; toegang voor deze persoon net vervallen.
const int mijnAdNummer = 12345;
Groep groep = new ChiroGroep
{
GebruikersRechtV2 = new[]
{
new GebruikersRechtV2
{
Persoon = new Persoon {
AdNummer = mijnAdNummer
},
VervalDatum = DateTime.Today.AddDays(1),
GroepsPermissies = Permissies.Bewerken
}
}
};
// Zet mock op voor het opleveren van gebruikersnaam
var authenticatieManagerMock = new Mock <IAuthenticatieManager>();
authenticatieManagerMock.Setup(src => src.AdNummerGet()).Returns(mijnAdNummer);
Factory.InstantieRegistreren(authenticatieManagerMock.Object);
// ACT
var target = Factory.Maak <AutorisatieManager>();
var actual = target.PermissiesOphalen(groep, SecurityAspect.PersonenInAfdeling);
// ASSERT
Assert.IsTrue(actual.HasFlag(Permissies.Bewerken));
}
public void LidMakenTest()
{
// Arrange
// Ik probeer iemand lid te maken die te jong is, en verwacht een exception.
var groep = new ChiroGroep()
{
ID = 1
};
var gwj = new GroepsWerkJaar {
WerkJaar = 2012, Groep = groep
}; // Werkjaar 2012-2013
var gp = new GelieerdePersoon
{
Persoon =
new Persoon
{
GeboorteDatum = new DateTime(2010, 06, 21), // Geboren in 2010
Geslacht = GeslachtsType.Vrouw,
},
Groep = groep
};
var target = new LedenManager();
// Assert
Assert.Throws <FoutNummerException>(() => target.NieuwInschrijven(
new LidVoorstel
{
GelieerdePersoon = gp,
GroepsWerkJaar = gwj,
AfdelingsJarenIrrelevant = true,
LeidingMaken = false
}, false));
}
public void AfdelingsJarenVoorstellenTest()
{
// ARRANGE: dom modelleke opbouwen
var groep = new ChiroGroep {
Afdeling = new List <Afdeling>(), GroepsWerkJaar = new List <GroepsWerkJaar>()
};
var groepsWerkJaar = new GroepsWerkJaar
{
WerkJaar = 2010,
ID = 2971,
Groep = groep,
AfdelingsJaar = new List <AfdelingsJaar>()
};
groep.GroepsWerkJaar.Add(groepsWerkJaar);
var afdeling = new Afdeling {
ID = 2337, ChiroGroep = groep
};
groep.Afdeling.Add(afdeling);
var afdelingsJaar = new AfdelingsJaar
{
GroepsWerkJaar = groepsWerkJaar, Afdeling = afdeling, GeboorteJaarVan = 2003, GeboorteJaarTot = 2004
};
groepsWerkJaar.AfdelingsJaar.Add(afdelingsJaar);
// ACT: stel nieuwe afdelingsjaren voor
var target = Factory.Maak <GroepsWerkJarenManager>();
var actual = target.AfdelingsJarenVoorstellen(groep, groep.Afdeling.ToList(), 2011, new OfficieleAfdeling());
// ASSERT
Assert.IsNotNull(actual);
Assert.IsNotNull(actual[0]);
Assert.AreEqual(actual[0].GeboorteJaarVan, afdelingsJaar.GeboorteJaarVan + 1);
Assert.AreEqual(actual[0].GeboorteJaarTot, afdelingsJaar.GeboorteJaarTot + 1);
}
public void ToekennenLidFunctieAanLeiding()
{
// Arrange
var fm = Factory.Maak <FunctiesManager>();
Groep groep = new ChiroGroep
{
Functie = new List <Functie>()
};
var functie = new Functie
{
Groep = groep,
MaxAantal = 1,
MinAantal = 0,
Niveau = Niveau.LidInGroep
};
groep.Functie.Add(functie);
var leider = new Leiding
{
GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
groep.GroepsWerkJaar.Add(leider.GroepsWerkJaar);
// Assert
Assert.Throws <FoutNummerException>(() => fm.Toekennen(leider, new List <Functie> {
functie
}));
}
public void FunctiesVervangen()
{
// Arrange
// testdata
var gwj = new GroepsWerkJaar();
var groep = new ChiroGroep
{
GroepsWerkJaar = new List <GroepsWerkJaar> {
gwj
}
};
gwj.Groep = groep;
var contactPersoon = new Functie
{
ID = 1,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "Contactpersoon",
Type = LidType.Leiding
};
var finVer = new Functie
{
ID = 2,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "FinancieelVerantwoordelijke",
Type = LidType.Leiding
};
var vb = new Functie
{
ID = 3,
IsNationaal = true,
Niveau = Niveau.Alles,
Naam = "VB",
Type = LidType.Leiding
};
var redactie = new Functie
{
ID = 4,
IsNationaal = false,
Niveau = Niveau.Groep,
Naam = "RED",
Type = LidType.Leiding,
Groep = groep
};
var leiding = new Leiding
{
ID = 100,
GroepsWerkJaar = gwj,
Functie = new List <Functie> {
contactPersoon, redactie
},
GelieerdePersoon = new GelieerdePersoon {
Groep = groep
}
};
var functiesMgr = Factory.Maak <FunctiesManager>();
// ACT
var leidingsFuncties = leiding.Functie; // bewaren voor latere referentie
functiesMgr.Vervangen(leiding, new List <Functie> {
finVer, vb, redactie
});
// ASSERT
Assert.AreEqual(leiding.Functie.Count(), 3);
Assert.IsTrue(leiding.Functie.Contains(finVer));
Assert.IsTrue(leiding.Functie.Contains(vb));
Assert.IsTrue(leiding.Functie.Contains(redactie));
// om problemen te vermijden met entity framework, mag je bestaande collecties niet zomaar vervangen;
// je moet entiteiten toevoegen aan/verwijderen uit bestaande collecties.
Assert.AreEqual(leiding.Functie, leidingsFuncties);
}
public void PlaatsVervangenTest()
{
// ARRANGE
var groep = new ChiroGroep {
ID = 3
};
var bivak = new Uitstap {
ID = 1, GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
var adres = new BuitenLandsAdres
{
Straat = "Vorststraat",
HuisNr = 3,
PostCode = "BR 1234",
WoonPlaats = "Killegem",
Land = new Land {
Naam = "Nederland"
}
};
var plaats = new Plaats {
ID = 2, Naam = "Coole bivakplaats", Adres = adres, Groep = groep
};
bivak.Plaats = plaats; // Bivak heeft al een plaats
// dependency injection voor data access
var dummyRepositoryProvider = new Mock <IRepositoryProvider>();
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Uitstap>())
.Returns(new DummyRepo <Uitstap>(new List <Uitstap> {
bivak
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Plaats>())
.Returns(new DummyRepo <Plaats>(new List <Plaats> {
plaats
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Adres>())
.Returns(new DummyRepo <Adres>(new List <Adres> {
adres
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Land>())
.Returns(new DummyRepo <Land>(new List <Land> {
adres.Land
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <WoonPlaats>())
.Returns(new DummyRepo <WoonPlaats>(new List <WoonPlaats>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <StraatNaam>())
.Returns(new DummyRepo <StraatNaam>(new List <StraatNaam>()));
Factory.InstantieRegistreren(dummyRepositoryProvider.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.PlaatsBewaren(bivak.ID, "Warme Bivakplaats",
new AdresInfo
{
StraatNaamNaam = "Zonnestraat",
HuisNr = 8,
PostNr = 9876,
PostCode = "PF",
WoonPlaatsNaam = "Warmegem",
LandNaam = "Nederland"
});
// ASSERT
Assert.AreNotEqual(bivak.Plaats.ID, plaats.ID); // is de plaats wel veranderd?
}
public void PlaatsOpGekendAdresBewarenTest()
{
// ARRANGE
var groep = new ChiroGroep {
ID = 3
};
var bivak = new Uitstap {
ID = 1, GroepsWerkJaar = new GroepsWerkJaar {
Groep = groep
}
};
var adres = new BuitenLandsAdres
{
Straat = "Vorststraat",
HuisNr = 3,
PostCode = "BR 1234",
WoonPlaats = "Killegem",
Land = new Land {
Naam = "Nederland"
}
};
// dependency injection voor data access
var dummyRepositoryProvider = new Mock <IRepositoryProvider>();
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Uitstap>())
.Returns(new DummyRepo <Uitstap>(new List <Uitstap> {
bivak
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Plaats>())
.Returns(new DummyRepo <Plaats>(new List <Plaats>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Adres>())
.Returns(new DummyRepo <Adres>(new List <Adres> {
adres
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <Land>())
.Returns(new DummyRepo <Land>(new List <Land> {
adres.Land
}));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <WoonPlaats>())
.Returns(new DummyRepo <WoonPlaats>(new List <WoonPlaats>()));
dummyRepositoryProvider.Setup(src => src.RepositoryGet <StraatNaam>())
.Returns(new DummyRepo <StraatNaam>(new List <StraatNaam>()));
Factory.InstantieRegistreren(dummyRepositoryProvider.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.PlaatsBewaren(bivak.ID, "Warme Bivakplaats",
new AdresInfo
{
StraatNaamNaam = adres.Straat,
HuisNr = adres.HuisNr,
PostCode = adres.PostCode,
WoonPlaatsNaam = adres.WoonPlaats,
LandNaam = adres.Land.Naam
});
// ASSERT
Assert.AreEqual(bivak.Plaats.Adres.ID, adres.ID);
}
public void DubbelVerwijderenTestOrigineelLidInactief()
{
// ARRANGE
var groep = new ChiroGroep();
var groepsWerkJaar = new GroepsWerkJaar {
Groep = groep
};
var origineel = new Persoon();
var dubbel = new Persoon();
var origineleGp = new GelieerdePersoon {
Persoon = origineel, Groep = groep
};
var dubbeleGp = new GelieerdePersoon {
Persoon = dubbel, Groep = groep
};
origineel.GelieerdePersoon.Add(origineleGp);
dubbel.GelieerdePersoon.Add(dubbeleGp);
groep.GelieerdePersoon.Add(origineleGp);
groep.GelieerdePersoon.Add(dubbeleGp);
var origineelLid = new Leiding
{
GelieerdePersoon = origineleGp,
GroepsWerkJaar = groepsWerkJaar,
UitschrijfDatum = DateTime.Today.AddDays(-1),
NonActief = true,
ID = 1
};
var dubbelLid = new Leiding
{
GelieerdePersoon = dubbeleGp,
GroepsWerkJaar = groepsWerkJaar,
UitschrijfDatum = null,
NonActief = false,
ID = 2
};
origineleGp.Lid.Add(origineelLid);
dubbeleGp.Lid.Add(dubbelLid);
groepsWerkJaar.Lid.Add(origineelLid);
groepsWerkJaar.Lid.Add(dubbelLid);
var allePersonen = new List <Persoon> {
origineel, dubbel
};
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Persoon>())
.Returns(new DummyRepo <Persoon>(allePersonen));
repositoryProviderMock.Setup(src => src.RepositoryGet <Lid>())
.Returns(new DummyRepo <Lid>(new List <Lid> {
origineelLid, dubbelLid
}));
repositoryProviderMock.Setup(src => src.RepositoryGet <GelieerdePersoon>())
.Returns(new DummyRepo <GelieerdePersoon>(new List <GelieerdePersoon> {
origineleGp, dubbeleGp
}));
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <GapUpdater>();
target.DubbelVerwijderen(origineel, dubbel);
// ASSERT
Assert.IsTrue(origineleGp.Lid.Contains(dubbelLid));
Assert.IsFalse(groepsWerkJaar.Lid.Contains(origineelLid));
}
/// <summary>
/// Stelt afdelingsjaren voor voor de gegeven <paramref name="groep"/> en <paramref name="afdelingen"/>
/// in het werkjaar <paramref name="nieuwWerkJaar"/> - <paramref name="nieuwWerkJaar"/>+1.
/// </summary>
/// <param name="groep">Groep waarvoor afdelingsjaren moeten worden voorgesteld, met daaraan gekoppeld
/// het huidige groepswerkjaar, de huidige afdelingsjaren, en alle beschikbare afdelingen.</param>
/// <param name="afdelingen">Afdelingen waarvoor afdelingsjaren moeten worden voorgesteld</param>
/// <param name="nieuwWerkJaar">Bepaalt het werkjaar waarvoor de afdelingsjaren voorgesteld moeten worden.</param>
/// <param name="standaardOfficieleAfdeling">Officiele afdeling die standaard voorgesteld moet worden als de
/// afdeling het laatste afdelingsjaar niet in gebruik was.</param>
/// <returns>Lijstje afdelingsjaren</returns>
public IList <AfdelingsJaar> AfdelingsJarenVoorstellen(ChiroGroep groep, IList <Afdeling> afdelingen,
int nieuwWerkJaar,
OfficieleAfdeling standaardOfficieleAfdeling)
{
// TODO: als een afdeling vorig jaar niet bestond, dan maken we een afdelingsjaar op basis van de meegegeven
// standaardOfficieleAfdeling. Dat kan beter. We zouden in eerste instantie kunnen nakijken of de afdeling
// in een vroeger afdelingsjaar gebruikt was. En in tweede instantie zouden we kunnen gokken op basis van
// de naam.
if (afdelingen.FirstOrDefault(afd => afd.ChiroGroep.ID != groep.ID) != null)
{
throw new FoutNummerException(FoutNummer.AfdelingNietVanGroep, Resources.AfdelingNietVanGroep);
}
var recentsteWerkjaar = groep.GroepsWerkJaar.OrderByDescending(gwj => gwj.WerkJaar).FirstOrDefault();
if (recentsteWerkjaar == null)
{
// Eigenlijk gaan we ervan uit dat elke groep al wel een afdelingsjaar heeft. Maar
// moest het toch niet zo zijn, dan geven we gauw een domme suggestie terug
return((from afd in afdelingen
select
new AfdelingsJaar
{
Afdeling = afd,
OfficieleAfdeling = standaardOfficieleAfdeling,
Geslacht = GeslachtsType.Gemengd
}).ToList());
}
var werkJarenVerschil = nieuwWerkJaar - recentsteWerkjaar.WerkJaar;
// We halen de afdelingsjaren van het huidige (oude) werkjaar op, zodat we op basis daarvan geboortejaren
// en geslacht voor de nieuwe afdelingsjaren in het nieuwe werkjaar kunnen voorstellen.
var huidigeAfdelingsJaren = recentsteWerkjaar.AfdelingsJaar;
// Creeer een voorstel voor de nieuwe afdelingsjaren
var nieuweAfdelingsJaren = new List <AfdelingsJaar>();
foreach (var afdeling in afdelingen)
{
// geboortejaren en geslacht gewoon default values, passen we zo nodig
// straks nog aan.
var afdelingsJaar = new AfdelingsJaar
{
Afdeling = afdeling,
GeboorteJaarVan = 0,
GeboorteJaarTot = 0,
Geslacht = GeslachtsType.Gemengd
};
nieuweAfdelingsJaren.Add(afdelingsJaar);
// Als de afdeling dit jaar al actief was, kunnen we de details automatisch bepalen
var bestaandAfdelingsJaar = (from aj in huidigeAfdelingsJaren
where aj.Afdeling.ID == afdeling.ID
select aj).FirstOrDefault();
if (bestaandAfdelingsJaar != null)
{
afdelingsJaar.OfficieleAfdeling = bestaandAfdelingsJaar.OfficieleAfdeling;
afdelingsJaar.Geslacht = bestaandAfdelingsJaar.Geslacht;
afdelingsJaar.GeboorteJaarTot = bestaandAfdelingsJaar.GeboorteJaarTot + werkJarenVerschil;
afdelingsJaar.GeboorteJaarVan = bestaandAfdelingsJaar.GeboorteJaarVan + werkJarenVerschil;
// 'Gemengd' werd geherdefinieerd sinds het gap het derde geslacht ondersteunt (#3814).
// De 'oude' interpretatie van gemengd moet nu vertaald worden naar M|V|X. (zie #3849).
if (afdelingsJaar.Geslacht == (GeslachtsType.Man | GeslachtsType.Vrouw))
{
afdelingsJaar.Geslacht = GeslachtsType.Gemengd;
}
}
else
{
// Als officiële afdeling, geven we ribbels, om te vermijden dat de groepen te snel
// 'speciaal' zouden kiezen.
// TODO: Als een afdeling vorig jaar niet gebruikt werd, zou het niet slecht zijn moesten
// we opgezocht hebben of ze in een erder verleden wel gebruikt is geweest.
afdelingsJaar.OfficieleAfdeling = standaardOfficieleAfdeling;
afdelingsJaar.Geslacht = GeslachtsType.Gemengd;
afdelingsJaar.GeboorteJaarTot = nieuwWerkJaar - standaardOfficieleAfdeling.LeefTijdVan;
afdelingsJaar.GeboorteJaarVan = nieuwWerkJaar - standaardOfficieleAfdeling.LeefTijdTot;
}
}
// Sorteer de afdelingsjaren: eerst die zonder geboortejaren, dan van jong naar oud
var resultaat = (from a in nieuweAfdelingsJaren
orderby a.GeboorteJaarTot descending
orderby a.GeboorteJaarTot == 0 descending
select a).ToArray();
return(resultaat);
}
