/// <summary>
/// Kijkt na voor een gegeven <paramref name="groepsWerkJaar"/> of de maximum- en
/// minimumaantallen van de functies <paramref name="functies"/> niet overschreden zijn.
/// </summary>
/// <param name="groepsWerkJaar">
/// Te controleren werkJaar
/// </param>
/// <param name="functies">
/// Functies waarop te controleren
/// </param>
/// <returns>
/// Een lijst met tellingsgegevens voor de functies waar de aantallen niet kloppen.
/// </returns>
/// <remarks>
/// <para>
/// Deze functie is zich niet bewust van de aanwezigheid van een database, en verwacht
/// dat groepsWerkJaar.Lid[i].Functie beschikbaar is.
/// </para>
/// <para>
/// Functies in <paramref name="functies"/> waar geen groep aan gekoppeld is, worden als
/// nationaal bepaalde functies beschouwd.
/// </para>
/// <para>
/// Functies die niet geldig zijn in het gevraagde groepswerkjaar, worden genegeerd
/// </para>
/// </remarks>
public List <Telling> AantallenControleren(
GroepsWerkJaar groepsWerkJaar,
IList <Functie> functies)
{
var toegekendeFuncties =
groepsWerkJaar.Lid.SelectMany(ld => ld.Functie)
.Where(functies.Contains);
// bovenstaande syntax is wat ongebruikelijker, maar wel juist. Ze is
// equivalent met .Where(fn => functies.Contains(fn))
var nietToegekendeFuncties = from fn in functies
where !toegekendeFuncties.Contains(fn) &&
(fn.IsNationaal || Equals(fn.Groep, groepsWerkJaar.Groep))
// bovenstaande vermijdt groepsvreemde functies
select fn;
// toegekende functies waarvan er te veel of te weinig zijn
var problemenToegekendeFuncties = from f in toegekendeFuncties
group f by f
into gegroepeerd
where (gegroepeerd.Key.WerkJaarVan == null || gegroepeerd.Key.WerkJaarVan <= groepsWerkJaar.WerkJaar) &&
(gegroepeerd.Key.WerkJaarTot == null || gegroepeerd.Key.WerkJaarTot >= groepsWerkJaar.WerkJaar)
&&
(gegroepeerd.Count() > gegroepeerd.Key.MaxAantal ||
gegroepeerd.Count() < gegroepeerd.Key.MinAantal)
select
new Telling
{
ID = gegroepeerd.Key.ID,
Aantal = gegroepeerd.Count(),
Max = gegroepeerd.Key.MaxAantal,
Min = gegroepeerd.Key.MinAantal
};
// niet-toegekende functies waarvan er te weinig zijn
var problemenOntbrekendeFuncties =
nietToegekendeFuncties.Where(fn => (fn.WerkJaarVan == null || fn.WerkJaarVan <= groepsWerkJaar.WerkJaar)
&&
(fn.WerkJaarTot == null || fn.WerkJaarTot >= groepsWerkJaar.WerkJaar) &&
fn.MinAantal > 0).Select(fn => new Telling
{
ID = fn.ID,
Aantal = 0,
Max = fn.MaxAantal,
Min = fn.MinAantal
});
return(problemenToegekendeFuncties.Union(problemenOntbrekendeFuncties).ToList());
}
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 InschrijvingVoorstellenTest()
{
// Arrange
var gp = new GelieerdePersoon
{
Persoon =
new Persoon
{
GeboorteDatum = new DateTime(1996, 03, 07),
Geslacht = GeslachtsType.Vrouw,
},
PersoonsAdres = new PersoonsAdres(),
};
var gwj = new GroepsWerkJaar {
WerkJaar = 2011, Groep = new ChiroGroep()
};
gp.Groep = gwj.Groep;
var afdelingsJaar1 = new AfdelingsJaar
{
ID = 1,
GeboorteJaarVan = 1996,
GeboorteJaarTot = 1997,
Geslacht = GeslachtsType.Man,
OfficieleAfdeling = new OfficieleAfdeling()
};
var afdelingsJaar2 = new AfdelingsJaar
{
ID = 2,
GeboorteJaarVan = 1996,
GeboorteJaarTot = 1997,
Geslacht = GeslachtsType.Vrouw,
OfficieleAfdeling = new OfficieleAfdeling()
};
gwj.AfdelingsJaar.Add(afdelingsJaar1);
gwj.AfdelingsJaar.Add(afdelingsJaar2);
var target = Factory.Maak <LedenManager>();
// Act
var actual = target.InschrijvingVoorstellen(gp, gwj, false);
// Assert
Assert.AreEqual(actual.AfdelingsJaren[0], afdelingsJaar2);
}
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 TweeKeerUniekeFunctieToekennenTestVerschillendLid()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var uniekeFunctie = new Functie
{
MaxAantal = 1,
Groep = groepsWerkJaar.Groep,
Niveau = Niveau.Groep
};
var lid1 = new Leiding {
GroepsWerkJaar = groepsWerkJaar, Functie = new List <Functie> {
uniekeFunctie
}
};
var lid2 = new Leiding {
GroepsWerkJaar = groepsWerkJaar
};
uniekeFunctie.Lid.Add(lid1);
groepsWerkJaar.Lid.Add(lid1);
groepsWerkJaar.Lid.Add(lid2);
// ACT
var functiesManager = Factory.Maak <FunctiesManager>();
functiesManager.Toekennen(lid2, new List <Functie> {
uniekeFunctie
});
// ASSERT
var issues = functiesManager.AantallenControleren(groepsWerkJaar, new List <Functie> {
uniekeFunctie
});
Assert.IsTrue(issues.Select(src => src.ID).Contains(uniekeFunctie.ID));
}
/// <summary>
/// Geeft <c>true</c> als de gelieerde persoon <paramref name="gp"/> leiding kan worden in
/// groepswerkjaar <paramref name="gwj"/>
/// </summary>
/// <param name="gp">Gelieerde persoon, waarvan nagegaan moet worden of hij/zij leiding kan worden</param>
/// <param name="gwj">Groepswerkjaar waarvoor gecontroleerd moet worden</param>
/// <returns><c>true</c> als de gelieerde persoon <paramref name="gp"/> leiding kan worden in
/// groepswerkjaar <paramref name="gwj"/></returns>
public bool KanLeidingWorden(GelieerdePersoon gp, GroepsWerkJaar gwj)
{
if (gp.Persoon.GeboorteDatum == null)
{
return(false);
}
// Gooi exception als groepswerkjaar van andere groep als gelieerde persoon.
if (!gp.Groep.Equals(gwj.Groep))
{
throw new FoutNummerException(FoutNummer.GroepsWerkJaarNietVanGroep, Resources.GroepsWerkJaarNietVanGroep);
}
Debug.Assert(gp.GebDatumMetChiroLeefTijd != null, "gp.GebDatumMetChiroLeefTijd != null");
return(KanLeidingWorden(gp.GebDatumMetChiroLeefTijd.Value, gwj));
}
/// <summary>
/// Maakt een nieuw groepswerkjaar in het gevraagde werkJaar.
/// Persisteert niet ;-P
/// </summary>
/// <param name="g">
/// De groep waarvoor een groepswerkjaar aangemaakt moet worden
/// </param>
/// <returns>
/// Het nieuwe groepswerkjaar
/// </returns>
/// <throws>OngeldigObjectException</throws>
public GroepsWerkJaar VolgendGroepsWerkJaarMaken(Groep g)
{
// Bereken gewenste werkjaar
// (die parameter g.ID is irrelevant, maar blijkbaar nodig voor een of andere
// unit test.)
int werkJaar = NieuweWerkJaar(g.ID);
// Controle op dubbels moet gebeuren door data access. (Zie #507)
var resultaat = new GroepsWerkJaar {
Groep = g, WerkJaar = werkJaar
};
g.GroepsWerkJaar.Add(resultaat);
return(resultaat);
}
public void ContactInstellenSaveTest()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep {
ID = 1
},
};
var bivak = new Uitstap
{
ID = 2,
IsBivak = true,
GroepsWerkJaar = groepsWerkJaar,
};
var deelnemer = new Deelnemer
{
ID = 3,
Uitstap = bivak,
GelieerdePersoon = new GelieerdePersoon {
Persoon = new Persoon()
}
};
groepsWerkJaar.Uitstap.Add(bivak);
// mock data acces
var deelnemersRepoMock = new DummyRepo <Deelnemer>(new List <Deelnemer> {
deelnemer
});
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Deelnemer>())
.Returns(deelnemersRepoMock);
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.ContactInstellen(deelnemer.ID);
// ASSERT
Assert.IsFalse(deelnemersRepoMock.SaveCount == 0);
}
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 BivakVerwijderenAlsGeenBivakMeerTest()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep {
ID = 1
},
};
var bivak = new Uitstap {
ID = 2, IsBivak = true, GroepsWerkJaar = groepsWerkJaar
};
groepsWerkJaar.Uitstap.Add(bivak);
var uitstapInfo = new UitstapInfo {
ID = bivak.ID, IsBivak = false
};
// mock synchronisatie voor kipadmin
var bivakSyncMock = new Mock <IBivakSync>();
bivakSyncMock.Setup(src => src.Verwijderen(bivak.ID)).Verifiable();
Factory.InstantieRegistreren(bivakSyncMock.Object);
// mock data acces
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <GroepsWerkJaar>())
.Returns(new DummyRepo <GroepsWerkJaar>(new List <GroepsWerkJaar> {
groepsWerkJaar
}));
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.Bewaren(groepsWerkJaar.Groep.ID, uitstapInfo);
// ASSERT
bivakSyncMock.Verify(src => src.Verwijderen(bivak.ID), Times.AtLeastOnce());
}
public void NietWerkjaarVerzekeringWelOverlap()
{
// ARRANGE
var vtype = new VerzekeringsType
{
TotEindeWerkJaar = false
};
var groepsWerkJaar = new GroepsWerkJaar
{
Groep = new ChiroGroep(),
WerkJaar = 2012
};
groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
var persoon = new Persoon
{
PersoonsVerzekering = new List <PersoonsVerzekering>
{
new PersoonsVerzekering
{
VerzekeringsType = vtype,
Van = new DateTime(2011, 10, 1),
Tot = new DateTime(2012, 8, 31)
}
}
};
var lid1 = new Leiding
{
GroepsWerkJaar = groepsWerkJaar,
GelieerdePersoon = new GelieerdePersoon {
Persoon = persoon
}
};
// ASSERT
var verzekeringenManager = Factory.Maak <VerzekeringenManager>();
Assert.Throws <BlokkerendeObjectenException <PersoonsVerzekering> >(() => verzekeringenManager.Verzekeren(lid1,
vtype, new DateTime(2012, 8, 1), new DateTime(2013, 8, 31)));
}
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);
}
/// <summary>
/// Verwijdert een groepswerkjaar in zijn geheel.
/// </summary>
/// <param name="groepsWerkJaar">Te verwijderen groepswerkjaar</param>
/// <param name="ledenRepo"></param>
/// <param name="gwjRepo"></param>
/// <param name="ajRepo"></param>
/// <remarks>
/// Dit werkt enkel als er geen liden zijn waarvan de probeerperiode voorbij is.
/// De repositories zijn nodig omdat ik anders geen entities kan verwijderen.
/// </remarks>
public void Verwijderen(GroepsWerkJaar groepsWerkJaar, IRepository <Lid> ledenRepo, IRepository <GroepsWerkJaar> gwjRepo, IRepository <AfdelingsJaar> ajRepo)
{
var leden = groepsWerkJaar.Lid;
// Verwijder afdelingen van leiding
if (leden.Any(ld => ld.EindeInstapPeriode < Vandaag() && !ld.NonActief))
{
throw new FoutNummerException(FoutNummer.LidWasAlIngeschreven, Resources.KanWerkjaarNietTerugDraaien);
}
var leiding = leden.OfType <Leiding>().ToList();
// Verwijder afdelingen van leiding
foreach (var l in leiding)
{
l.AfdelingsJaar.Clear();
}
// Verwijder functies van leden (kind of leiding)
foreach (var l in leden)
{
l.Functie.Clear();
}
// Verwijder leden
ledenRepo.Delete(groepsWerkJaar.Lid.ToList());
// Verwijder afdelingsjaren
ajRepo.Delete(groepsWerkJaar.AfdelingsJaar.ToList());
if (groepsWerkJaar.Uitstap.Any())
{
// Koppel eventuele uitstappen aan het vorige jaar.
// (De jaarovergang zou die koppeling moeten herstellen, zie #1292)
var vorigGwj = groepsWerkJaar.Groep.GroepsWerkJaar.OrderBy(gwj => gwj.WerkJaar).Skip(1).FirstOrDefault();
foreach (var u in groepsWerkJaar.Uitstap)
{
u.GroepsWerkJaar = vorigGwj;
}
}
gwjRepo.Delete(groepsWerkJaar);
}
public void BewarenTest()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar {
Groep = new ChiroGroep()
};
var gelieerdePersoon = new GelieerdePersoon
{
Groep = groepsWerkJaar.Groep,
Persoon = new Persoon
{
AdNummer = null,
InSync = true,
}
};
gelieerdePersoon.Persoon.GelieerdePersoon.Add(gelieerdePersoon);
groepsWerkJaar.Groep.GelieerdePersoon.Add(gelieerdePersoon);
var persoonsVerzekering = new PersoonsVerzekering
{
Persoon = gelieerdePersoon.Persoon
};
var kipSyncMock = new Mock <ISyncPersoonService>();
kipSyncMock.Setup(
src =>
src.LoonVerliesVerzekerenAdOnbekend(It.IsAny <PersoonDetails>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>())).Verifiable();
Factory.InstantieRegistreren(kipSyncMock.Object);
// ACT
var target = Factory.Maak <VerzekeringenSync>();
target.Bewaren(persoonsVerzekering, groepsWerkJaar);
// ASSERT
kipSyncMock.VerifyAll();
}
public void AantallenControlerenBovengrensTest()
{
// ARRANGE
var functie = new Functie {
IsNationaal = true, MaxAantal = 1
};
var groepsWerkJaar1 = new GroepsWerkJaar();
var leiding1 = new Leiding {
Functie = new List <Functie> {
functie
}
};
functie.Lid.Add(leiding1);
groepsWerkJaar1.Lid.Add(leiding1);
var groepsWerkJaar2 = new GroepsWerkJaar();
var leiding2 = new Leiding {
Functie = new List <Functie> {
functie
}
};
functie.Lid.Add(leiding2);
groepsWerkJaar2.Lid.Add(leiding2);
// ACT
var target = Factory.Maak <FunctiesManager>();
var actual = target.AantallenControleren(groepsWerkJaar1, new List <Functie> {
functie
});
// controleer enkel op functie2.
// ASSERT
Assert.AreEqual(0, actual.Count);
}
public void BewarenTest()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar {
Groep = new ChiroGroep {
ID = 1
}
};
var uitstapInfo = new UitstapInfo {
IsBivak = true
};
var gwjRepo = new DummyRepo <GroepsWerkJaar>(new List <GroepsWerkJaar> {
groepsWerkJaar
});
// mock synchronisatie voor kipadmin
var bivakSyncMock = new Mock <IBivakSync>();
bivakSyncMock.Setup(src => src.Bewaren(It.IsAny <Uitstap>()))
// controleer of het bivak bewaard werd voor de sync.
.Callback((() => Assert.AreNotEqual(0, gwjRepo.SaveCount)))
.Verifiable();
Factory.InstantieRegistreren(bivakSyncMock.Object);
// mock data acces
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <GroepsWerkJaar>())
.Returns(gwjRepo);
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <UitstappenService>();
target.Bewaren(groepsWerkJaar.Groep.ID, uitstapInfo);
// ASSERT
bivakSyncMock.Verify(src => src.Bewaren(It.IsAny <Uitstap>()), Times.AtLeastOnce());
}
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);
}
/// <summary>
/// Bepaalt de status van het gegeven <paramref name="groepsWerkJaar"/>.
/// </summary>
/// <param name="groepsWerkJaar"></param>
/// <returns>De status van het gegeven <paramref name="groepsWerkJaar"/>.</returns>
public WerkJaarStatus StatusBepalen(GroepsWerkJaar groepsWerkJaar)
{
DateTime vandaag = Vandaag();
int huidigWerkJaar = _veelGebruikt.WerkJaarOphalen(groepsWerkJaar.Groep);
if (groepsWerkJaar.WerkJaar < huidigWerkJaar)
{
return(WerkJaarStatus.Voorbij);
}
var status = OvergangMogelijk(vandaag, groepsWerkJaar.WerkJaar)
? WerkJaarStatus.InOvergang
: WerkJaarStatus.Bezig;
if (status == WerkJaarStatus.Bezig && !groepsWerkJaar.Lid.Any(l => !l.NonActief && l.EindeInstapPeriode < vandaag))
{
// We gebruiken niet l.IsAangesloten, want die wordt pas gezet als er
// teruggecommuniceerd wordt van Civi naar GAP. Als er leden zijn met
// instapperiode voorbij, kan het werkjaar niet meer teruggedraaid worden.
status = WerkJaarStatus.KanTerugDraaien;
}
return(status);
}
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 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 IrrelevanteVerplichteFunctie()
{
// ARRANGE
var groepsWerkJaar = new GroepsWerkJaar {
Groep = new ChiroGroep(), WerkJaar = 2012
};
var vervallenFunctie = new Functie
{
WerkJaarTot = groepsWerkJaar.WerkJaar - 1,
MinAantal = 1,
Groep = groepsWerkJaar.Groep
};
// ACT
var functiesManager = Factory.Maak <FunctiesManager>();
var probleemIDs = functiesManager.AantallenControleren(groepsWerkJaar, new List <Functie> {
vervallenFunctie
}).Select(src => src.ID);
// ASSERT
Assert.IsFalse(probleemIDs.Contains(vervallenFunctie.ID));
}
/// <summary>
/// Maakt een afdelingsjaar voor een groep en een afdeling, persisteert niet.
/// </summary>
/// <param name="a">
/// Afdeling voor nieuw afdelingsjaar
/// </param>
/// <param name="oa">
/// Te koppelen officiële afdeling
/// </param>
/// <param name="gwj">
/// Groepswerkjaar (koppelt de afdeling aan een groep en een werkJaar)
/// </param>
/// <param name="geboorteJaarBegin">
/// Geboortejaar van
/// </param>
/// <param name="geboorteJaarEind">
/// Geboortejaar tot
/// </param>
/// <param name="geslacht">
/// Bepaalt of de afdeling een jongensafdeling, meisjesafdeling of
/// gemengde afdeling is.
/// </param>
/// <returns>
/// Het aangemaakte afdelingsjaar
/// </returns>
public AfdelingsJaar Aanmaken(
Afdeling a,
OfficieleAfdeling oa,
GroepsWerkJaar gwj,
int geboorteJaarBegin,
int geboorteJaarEind,
GeslachtsType geslacht)
{
var afdelingsJaar = new AfdelingsJaar
{
OfficieleAfdeling = oa,
Afdeling = a,
GroepsWerkJaar = gwj,
GeboorteJaarVan = geboorteJaarBegin,
GeboorteJaarTot = geboorteJaarEind,
Geslacht = geslacht
};
// TODO check if no conflicts with existing afdelingsjaar
a.AfdelingsJaar.Add(afdelingsJaar);
oa.AfdelingsJaar.Add(afdelingsJaar);
gwj.AfdelingsJaar.Add(afdelingsJaar);
FoutNummer?afdelingsJaarFout = new AfdelingsJaarValidator().FoutNummer(afdelingsJaar);
if (afdelingsJaarFout == FoutNummer.OngeldigeGeboorteJarenVoorAfdeling)
{
throw new FoutNummerException(afdelingsJaarFout.Value, Resources.OngeldigeGeboorteJarenVoorAfdeling);
}
if (afdelingsJaarFout != null)
{
throw new FoutNummerException(afdelingsJaarFout.Value, Resources.AfdelingsJaarOngeldig);
}
return(afdelingsJaar);
}
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 bool IsGav(GroepsWerkJaar groepsWerkJaar)
{
return(true);
}
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));
}
public bool IsGav(GroepsWerkJaar groepsWerkJaar)
{
throw new NotImplementedException();
}
/// <summary>
/// Berekent de theoretische einddatum van het gegeven groepswerkjaar.
/// </summary>
/// <param name="groepsWerkJaar">
/// Groepswerkjaar, met daaraan gekoppeld een werkjaarobject
/// </param>
/// <returns>
/// Einddatum van het gekoppelde werkJaar.
/// </returns>
public DateTime EindDatum(GroepsWerkJaar groepsWerkJaar)
{
DateTime wjStart = Settings.Default.WerkjaarStartNationaal;
return(new DateTime(groepsWerkJaar.WerkJaar + 1, wjStart.Month, wjStart.Day).AddDays(-1));
}
public bool IsGav(GroepsWerkJaar groepsWerkJaar)
{
return(false);
}
/// <summary>
/// Sluit het gegeven groepswerkjaar <paramref name="gwj"/> af in Civi. Dat komt erop neer dat
/// alle lidrelaties worden beeindigd.
/// </summary>
/// <param name="gwj">Af te sluiten groepswerkjaar.</param>
public void WerkjaarAfsluiten(GroepsWerkJaar gwj)
{
Debug.Assert(gwj.WerkJaar != 0);
ServiceHelper.CallService <ISyncPersoonService>(svc => svc.GroepsWerkjaarAfsluiten(gwj.Groep.Code, gwj.WerkJaar));
}
