public void Updaten(GelieerdePersoon gp)
{
if (gp == null)
{
throw new ArgumentNullException("gp");
}
}
public void ValidatieLidVoorstelZonderTelefoonNummer()
{
// Arrange
// Ik maak een persoon, en een werkjaar met 2 afdelingen. Maar dat is hier
// niet relevant. Wat wel van belang is, is dat de persoon te jong is om
// lid te worden. We verwachten dat het maken van een lidvoorstel crasht.
var gwj = new GroepsWerkJaar {
WerkJaar = 2014, Groep = new ChiroGroep()
}; // Werkjaar 2012-2013
var gp = new GelieerdePersoon
{
Persoon =
new Persoon
{
GeboorteDatum = new DateTime(2000, 06, 21),
Geslacht = GeslachtsType.Vrouw,
},
Groep = gwj.Groep,
PersoonsAdres = new PersoonsAdres(),
Communicatie = new List <CommunicatieVorm>() // geen telefoonnummer
};
gwj.AfdelingsJaar.Add(new AfdelingsJaar
{
ID = 1,
GeboorteJaarVan = 1999,
GeboorteJaarTot = 2000,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling()
});
gwj.AfdelingsJaar.Add(new AfdelingsJaar
{
ID = 2,
GeboorteJaarVan = 1997,
GeboorteJaarTot = 1998,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling()
});
var lidVoorstel = new LidVoorstel
{
GelieerdePersoon = gp,
GroepsWerkJaar = gwj,
AfdelingsJarenIrrelevant = true,
LeidingMaken = false
};
var target = new LidVoorstelValidator();
// Act
var foutNummer = target.FoutNummer(lidVoorstel);
// Assert
Assert.AreEqual(FoutNummer.TelefoonNummerOntbreekt, foutNummer);
}
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 AlleAbonnementenVerwijderenGeenEmailTest()
{
// ARRANGE
var gelieerdePersoon = new GelieerdePersoon
{
Communicatie = new List <CommunicatieVorm>(),
Persoon = new Persoon {
AdNummer = 1
}
};
// Verwacht dat er een (dummy) e-mailadres meegegeven wordt.
var kipSyncMock = new Mock <ISyncPersoonService>();
kipSyncMock.Setup(src => src.AbonnementStopzetten(It.Is <int>(ad => ad == gelieerdePersoon.Persoon.AdNummer.Value)))
.Verifiable();
Factory.InstantieRegistreren(kipSyncMock.Object);
// ACT
var target = Factory.Maak <AbonnementenSync>();
target.AlleAbonnementenVerwijderen(gelieerdePersoon);
// ASSERT
kipSyncMock.VerifyAll();
}
/// <summary>
/// Levert het contact-e-mailadres op van een gelieerde persoon
/// </summary>
/// <param name="gelieerdePersoon">Gelieerde persoon waarvan contact-e-mailadres opgeleverd moet worden</param>
/// <returns>Het betreffende e-mailadres</returns>
/// <remarks>Als er geen e-mailadres de voorkeur heeft, wordt gewoon een willekeurig opgeleverd. Of
/// <c>null</c>, als er geen e-mailadressen zijn</remarks>
public string ContactEmail(GelieerdePersoon gelieerdePersoon)
{
return((from cv in gelieerdePersoon.Communicatie
where cv.CommunicatieType.ID == (int)(CommunicatieTypeEnum.Email)
orderby cv.Voorkeur
select cv.Nummer).LastOrDefault());
}
public void AdresToevoegenVoorkeurTest()
{
// ARRANGE
var gelieerdePersoon = new GelieerdePersoon {
Persoon = new Persoon()
};
gelieerdePersoon.Persoon.GelieerdePersoon.Add(gelieerdePersoon);
var adres = new BelgischAdres();
// ACT
var target = new GelieerdePersonenManager();
target.AdresToevoegen(new List <GelieerdePersoon> {
gelieerdePersoon
}, adres, AdresTypeEnum.Thuis, true);
// ASSERT
// vind het persoonsadresobject
var persoonsAdres = gelieerdePersoon.Persoon.PersoonsAdres.First();
// weet het persoonsadresobject dat het voorkeursadres is?
Assert.IsNotNull(persoonsAdres.GelieerdePersoon.FirstOrDefault());
}
public void Check(GelieerdePersoon g)
{
if (g == null || !_autorisatieMgr.IsGav(g))
{
throw FaultExceptionHelper.GeenGav();
}
}
/// <summary>
/// Maakt gelieerde persoon leiding voor het gegeven werkJaar.
/// <returns>
/// Nieuw leidingsobject; niet gepersisteerd
/// </returns>
/// <remarks>
/// Private; andere lagen moeten via 'Inschrijven' gaan.
/// <para>
/// </para>
/// Deze method mag niet geexposed worden via de services, omdat een gebruiker uiteraard enkel in het huidige groepswerkjaar leden
/// kan maken.
/// <para>
/// </para>
/// Voorlopig gaan we ervan uit dat aan een gelieerde persoon al zijn vorige lidobjecten met
/// groepswerkjaren gekoppeld zijn. Dit wordt gebruikt in LidMaken
/// om na te kijken of een gelieerde persoon al eerder lid was. Dit lijkt me echter niet nodig; zie de commentaar aldaar.
/// </remarks>
/// <throws>FoutNummerException</throws>
/// <throws>GeenGavException</throws>
/// </summary>
/// <param name="gp">
/// Gelieerde persoon, gekoppeld met groep en persoon
/// </param>
/// <param name="gwj">
/// Groepswerkjaar waarin leiding te maken
/// </param>
/// <param name="isJaarovergang">
/// Geeft aan of het over de automatische jaarovergang gaat.
/// (relevant voor probeerperiode)
/// </param>
/// <param name="afdelingsJaren">
/// De afdelingsjaren waarin de nieuwe leiding zeker moet ingeschreven worden
/// </param>
/// <returns>
/// Het aangemaakte Leiding-object
/// </returns>
private Leiding LeidingMaken(GelieerdePersoon gp,
GroepsWerkJaar gwj,
bool isJaarovergang,
IEnumerable <AfdelingsJaar> afdelingsJaren)
{
Debug.Assert(gp != null && gp.GebDatumMetChiroLeefTijd != null);
if (!KanLeidingWorden(gp, gwj))
{
throw new FoutNummerException(FoutNummer.LeidingTeJong, Resources.TeJongVoorLeiding);
}
var leiding = LidMaken(gp, gwj, LidType.Leiding, isJaarovergang) as Leiding;
Debug.Assert(leiding != null);
if (afdelingsJaren != null)
{
foreach (var a in afdelingsJaren)
{
leiding.AfdelingsJaar.Add(a);
a.Leiding.Add(leiding);
}
}
return(leiding);
}
public void ToekennenTest()
{
// ARRANGE
var gelieerdePersoon = new GelieerdePersoon
{
ID = 1,
Groep = new ChiroGroep {
ID = 3
},
Persoon = new Persoon {
ID = 2
}
};
gelieerdePersoon.Persoon.GelieerdePersoon.Add(gelieerdePersoon);
// ACT
var target = new GebruikersRechtenManager();
target.ToekennenOfWijzigen(gelieerdePersoon.Persoon, gelieerdePersoon.Groep, Permissies.Bewerken,
Permissies.Bewerken, Permissies.Bewerken, Permissies.Bewerken);
var result = gelieerdePersoon.Persoon.GebruikersRechtV2.FirstOrDefault();
// ASSERT
Assert.IsNotNull(result);
Assert.AreEqual(gelieerdePersoon.Groep, result.Groep);
Assert.AreEqual(Permissies.Bewerken, result.PersoonsPermissies);
Assert.AreEqual(Permissies.Bewerken, result.GroepsPermissies);
Assert.AreEqual(Permissies.Bewerken, result.AfdelingsPermissies);
Assert.AreEqual(Permissies.Bewerken, result.IedereenPermissies);
}
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);
}
/// <summary>
/// Probeert de gegeven gelieerde persoon in de Chirocivi te vinden, en updatet
/// hem als dat lukt. Wordt de persoon niet gevonden, dan wordt er een
/// nieuwe aangemaakt.
/// </summary>
/// <param name="gp">Te bewaren gelieerde persoon</param>
public void UpdatenOfMaken(GelieerdePersoon gp)
{
Debug.Assert(gp.Persoon.InSync);
var details = MappingHelper.Map <GelieerdePersoon, PersoonDetails>(gp);
ServiceHelper.CallService <ISyncPersoonService>(svc => svc.PersoonUpdatenOfMaken(details));
}
/// <summary>
/// Levert alle gelieerde personen op uit dezelfde persoon als <paramref name="gelieerdePersoon"/>, die minstens
/// een adres gemeenschappelijk hebben met die <paramref name="gelieerdePersoon"/>.
/// </summary>
/// <param name="gelieerdePersoon">Eem gelieerde persoon</param>
/// <returns>Alle gelieerde personen uit dezelfde persoon als <paramref name="gelieerdePersoon"/>, die minstens
/// een adres gemeenschappelijk hebben met die <paramref name="gelieerdePersoon"/>.</returns>
public GelieerdePersoon[] AdresGenotenUitZelfdeGroep(GelieerdePersoon gelieerdePersoon)
{
// We trekken het wat uit elkaar om makkelijker te kunnen debuggen.
var persoonsAdressen = gelieerdePersoon.Persoon.PersoonsAdres.SelectMany(pa => pa.Adres.PersoonsAdres);
var gelieerdePersonen = persoonsAdressen.SelectMany(pa => pa.Persoon.GelieerdePersoon);
return(gelieerdePersonen.Where(gp => Equals(gp.Groep, gelieerdePersoon.Groep)).ToArray());
}
/// <summary>
/// Voorkeurtelefoonnr, voorkeurmailadres, ... van een gelieerde persoon
/// </summary>
/// <param name="gp">Gelieerde persoon</param>
/// <param name="type">Communicatietype waarvan voorkeur gevraagd wordt.</param>
/// <returns>Voorkeurtelefoonnr, -mailadres,... van de gelieerde persoon.
/// <c>null</c> indien onbestaand.</returns>
private string VoorkeurCommunicatie(GelieerdePersoon gp, CommunicatieTypeEnum type)
{
var query = from c in gp.Communicatie
where (c.CommunicatieType.ID == (int)type) && c.Voorkeur
select c.Nummer;
return(query.FirstOrDefault());
}
public void ValidatieLidVoorstelKleutersTest()
{
// Arrange
// Ik maak een persoon, en een werkjaar met 2 afdelingen. Maar dat is hier
// niet relevant. Wat wel van belang is, is dat de persoon te jong is om
// lid te worden.
var gwj = new GroepsWerkJaar {
WerkJaar = 2012, Groep = new ChiroGroep()
}; // Werkjaar 2012-2013
var gp = new GelieerdePersoon
{
Persoon =
new Persoon
{
GeboorteDatum = new DateTime(2010, 06, 21), // Geboren in 2010
Geslacht = GeslachtsType.Vrouw,
},
Groep = gwj.Groep
};
gwj.AfdelingsJaar.Add(new AfdelingsJaar
{
ID = 1,
GeboorteJaarVan = 1999,
GeboorteJaarTot = 2000,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling()
});
gwj.AfdelingsJaar.Add(new AfdelingsJaar
{
ID = 2,
GeboorteJaarVan = 1997,
GeboorteJaarTot = 1998,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling()
});
var lidVoorstel = new LidVoorstel
{
GelieerdePersoon = gp,
GroepsWerkJaar = gwj,
AfdelingsJarenIrrelevant = true,
LeidingMaken = false
};
var target = new LidVoorstelValidator();
// Act
var foutNummer = target.FoutNummer(lidVoorstel);
// Assert
Assert.AreEqual(FoutNummer.LidTeJong, 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);
}
private static string VoorkeursMail(GelieerdePersoon gelieerdePersoon)
{
string result = (from a in gelieerdePersoon.Communicatie
where a.CommunicatieType.ID == 3
orderby a.Voorkeur descending
select a.Nummer).FirstOrDefault();
return(result);
}
public void InschrijvingVoorstellenTest1()
{
// Arrange
// Ik maak een persoon, en een werkjaar met 2 afdelingen, zodanig dat
// de geboortedatum van die persoon buiten de afdelingen valt. We verwachten
// de afdeling die het meest logisch is (kleinste verschil met geboortedatum)
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 = 1999,
GeboorteJaarTot = 2000,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling(),
GroepsWerkJaar = gwj
};
var afdelingsJaar2 = new AfdelingsJaar
{
ID = 2,
GeboorteJaarVan = 1997,
GeboorteJaarTot = 1998,
Geslacht = GeslachtsType.Gemengd,
OfficieleAfdeling = new OfficieleAfdeling(),
GroepsWerkJaar = gwj
};
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 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 DubbelVerwijderenGedeeldAdresTest()
{
// ARRANGE
var origineel = new Persoon();
var dubbel = new Persoon();
var gelieerdeOrigineel = new GelieerdePersoon {
Persoon = origineel, Groep = new ChiroGroep()
};
var gelieerdeDubbel = new GelieerdePersoon {
Persoon = dubbel, Groep = new ChiroGroep()
};
origineel.GelieerdePersoon.Add(gelieerdeOrigineel);
dubbel.GelieerdePersoon.Add(gelieerdeDubbel);
var adres = new BelgischAdres();
var origineelPa = new PersoonsAdres {
Persoon = origineel, Adres = adres
};
var dubbelPa = new PersoonsAdres {
Persoon = dubbel, Adres = adres
};
adres.PersoonsAdres.Add(origineelPa);
adres.PersoonsAdres.Add(dubbelPa);
origineel.PersoonsAdres.Add(origineelPa);
dubbel.PersoonsAdres.Add(dubbelPa);
var allePersonen = new List <Persoon> {
origineel, dubbel
};
var allePersoonsAdressen = new List <PersoonsAdres> {
origineelPa, dubbelPa
};
var repositoryProviderMock = new Mock <IRepositoryProvider>();
repositoryProviderMock.Setup(src => src.RepositoryGet <Persoon>())
.Returns(new DummyRepo <Persoon>(allePersonen));
repositoryProviderMock.Setup(src => src.RepositoryGet <PersoonsAdres>())
.Returns(new DummyRepo <PersoonsAdres>(allePersoonsAdressen));
Factory.InstantieRegistreren(repositoryProviderMock.Object);
// ACT
var target = Factory.Maak <GapUpdater>();
target.DubbelVerwijderen(origineel, dubbel);
// ASSERT
Assert.AreEqual(1, allePersoonsAdressen.Count);
}
/// <summary>
/// Zoekt een afdelingsjaar van het recentste groepswerkjaar, waarin de gegeven
/// <paramref name="gelieerdePersoon"/> (kind)lid zou kunnen worden. <c>null</c> als er zo geen
/// bestaat.
/// </summary>
/// <param name="gelieerdePersoon">gelieerde persoon waarvoor we een afdeling zoeken</param>
/// <returns>een afdelingsjaar van het recentste groepswerkjaar, waarin de gegeven
/// <paramref name="gelieerdePersoon"/> lid zou kunnen worden. <c>null</c> als er zo geen
/// bestaat.</returns>
public AfdelingsJaar AfdelingsJaarVoorstellen(GelieerdePersoon gelieerdePersoon)
{
if (!gelieerdePersoon.Groep.GroepsWerkJaar.Any())
{
return(null);
}
return(AfdelingsJaarVoorstellen(gelieerdePersoon,
gelieerdePersoon.Groep.GroepsWerkJaar.OrderByDescending(gwj => gwj.WerkJaar)
.First()));
}
/// <summary>
/// Geeft aan of het voorkeurmailadres van een gelieerde persoon verdacht is
/// </summary>
/// <param name="gp">Gelieerde persoon</param>
/// <returns><c>True</c> als controle ervoor zorgde dat het adres gevlagd werd,
/// <c>false</c> als dat niet het geval is</returns>
private bool VoorkeurmailadresIsVerdacht(GelieerdePersoon gp)
{
var typeID = CommunicatieTypeEnum.Email;
var query = from c in gp.Communicatie
where (c.CommunicatieType.ID == (int)typeID) && c.Voorkeur
select c.IsVerdacht;
return(query.FirstOrDefault());
}
/// <summary>
/// Bepaalt het deelnemertype van een <paramref name="gelieerdePersoon"/> als hij voor een uitstap wordt
/// ingeschreven die plaats vindt vanaf <paramref name="datum"/>.
/// Als de person op dat moment lid is, dan is het deelnemer. Is de persoon op dat moment leiding, dan
/// is het begeleiding, en anders is het onbekend.
/// </summary>
/// <param name="gelieerdePersoon">Gelieerde persoon met te bepalen DeelnemerType</param>
/// <param name="datum">Datum voor deelnemertype</param>
/// <returns>Als de persoon op de gegeven <paramref name="datum"/> lid is, dan Deelnemers. Is hij \
/// leiding, dan Begeleiding. En anders onbekend.</returns>
private DeelnemerType DeelnemerTypeBepalen(GelieerdePersoon gelieerdePersoon, DateTime datum)
{
int werkJaar = _groepsWerkJarenMgr.WerkJaarNationaal(datum);
var lid =
(from l in gelieerdePersoon.Lid where l.GroepsWerkJaar.WerkJaar == werkJaar select l).FirstOrDefault();
return(lid == null
? DeelnemerType.Onbekend
: lid is Kind ? DeelnemerType.Deelnemer : DeelnemerType.Begeleiding);
}
/// <summary>
/// Updatet een bestaand persoon in Kipadmin: persoonsgegevens, en eventueel ook adressen en/of communicatie.
///
/// </summary>
/// <param name="gp">Gelieerde persoon, persoonsinfo</param>
/// <remarks>Enkel voor het wijzigen van bestaande personen!</remarks>
public void Updaten(GelieerdePersoon gp)
{
// Wijzigingen van personen met ad-nummer worden doorgesluisd
// naar Kipadmin.
Debug.Assert(gp.Persoon.InSync);
var syncPersoon = MappingHelper.Map <Persoon, Kip.ServiceContracts.DataContracts.Persoon>(gp.Persoon);
ServiceHelper.CallService <ISyncPersoonService>(svc => svc.PersoonUpdaten(syncPersoon));
}
/// <summary>
/// Geeft <c>true</c> als de gegeven <paramref name="gelieerdePersoon"/> in zijn recentste groepswerkjaar
/// lid kan worden, d.w.z. dat hij qua (Chiro)leeftijd in een afdeling past.
/// </summary>
/// <param name="gelieerdePersoon">een gelieerde persoon</param>
/// <returns><c>true</c> als de gegeven <paramref name="gelieerdePersoon"/> in zijn recentste groepswerkjaar
/// lid kan worden, d.w.z. dat hij qua (Chiro)leeftijd in een afdeling past.</returns>
public bool KanInschrijvenAlsKind(GelieerdePersoon gelieerdePersoon)
{
try
{
return(AfdelingsJaarVoorstellen(gelieerdePersoon) != null);
}
catch (FoutNummerException)
{
return(false);
}
}
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 ValidatieLidVoorstelLeidingZonderEmail()
{
// Arrange
// Ik maak een persoon, en een werkjaar met 2 afdelingen. Maar dat is hier
// niet relevant. Wat wel van belang is, is dat de persoon te jong is om
// lid te worden. We verwachten dat het maken van een lidvoorstel crasht.
var gwj = new GroepsWerkJaar {
WerkJaar = 2014, Groep = new ChiroGroep()
}; // Werkjaar 2012-2013
var gp = new GelieerdePersoon
{
Persoon =
new Persoon
{
GeboorteDatum = new DateTime(1995, 06, 21),
Geslacht = GeslachtsType.Vrouw,
},
Groep = gwj.Groep,
PersoonsAdres = new PersoonsAdres(),
Communicatie = new List <CommunicatieVorm>
{
// Enkel telefoonnummer; e-mailadres ontbreekt.
new CommunicatieVorm
{
CommunicatieType = new CommunicatieType {
ID = (int)CommunicatieTypeEnum.TelefoonNummer
}
}
}
};
var lidVoorstel = new LidVoorstel
{
GelieerdePersoon = gp,
GroepsWerkJaar = gwj,
AfdelingsJaren = new List <AfdelingsJaar>(),
AfdelingsJarenIrrelevant = false,
LeidingMaken = true
};
var target = new LidVoorstelValidator();
// Act
var foutNummer = target.FoutNummer(lidVoorstel);
// Assert
Assert.AreEqual(FoutNummer.EMailVerplicht, foutNummer);
}
public void KoppelenVoorkeursCommunicatieTest()
{
// Arrange
const int TESTGPID = 1234; // arbitrair ID van een gelieerde persoon
const int TESTCVID = 2345; // en van een communicatievorm
const int TESTCTID = 3; // en diens communicatietype
var testCommunicatieType = new CommunicatieType {
ID = TESTCTID, Validatie = ".*"
};
var testCommunicatieVorm = new CommunicatieVorm
{
ID = TESTCVID,
CommunicatieType = testCommunicatieType,
Nummer = "*****@*****.**",
Voorkeur = true
};
// Koppel gauw testCommunicatieVorm aan testGelieerdePersoon
var testGelieerdePersoon = new GelieerdePersoon
{
ID = TESTGPID,
Persoon = new Persoon(),
Communicatie =
new EntityCollection <CommunicatieVorm>
{
testCommunicatieVorm
}
};
testCommunicatieVorm.GelieerdePersoon = testGelieerdePersoon;
var target = Factory.Maak <CommunicatieVormenManager>();
CommunicatieVorm nieuwecv = new CommunicatieVorm
{
CommunicatieType = testCommunicatieType, // e-mail
ID = 0, // nieuwe communicatievorm
Nummer = "*****@*****.**", // arbitrair nieuw e-mailadres
Voorkeur = true
};
// act
target.Koppelen(testGelieerdePersoon, nieuwecv);
// assert
Assert.IsFalse(testCommunicatieVorm.Voorkeur);
}
public GebruikersRechtV2 GebruikersRechtOpEigenGroep(GelieerdePersoon gp)
{
return(new GebruikersRechtV2
{
Persoon = gp.Persoon,
Groep = gp.Groep,
PersoonsPermissies = Permissies.Bewerken,
GroepsPermissies = Permissies.Bewerken,
AfdelingsPermissies = Permissies.Bewerken,
IedereenPermissies = Permissies.Bewerken,
VervalDatum = DateTime.Now.AddDays(1)
});
}
/// <summary>
/// Als de gegeven <paramref name="gelieerdePersoon"/> lid is in het huidige werkjaar van zijn groep, dan
/// levert deze method het overeenkomstige lidobject op. In het andere geval <c>null</c>.
/// </summary>
/// <param name="gelieerdePersoon">Een gelieerde persoon</param>
/// <returns>
/// Als de gegeven <paramref name="gelieerdePersoon"/> lid is in het huidige werkjaar van zijn groep, dan
/// levert deze method het overeenkomstige lidobject op. In het andere geval <c>null</c>.
/// </returns>
public Lid HuidigLidGet(GelieerdePersoon gelieerdePersoon)
{
if (!gelieerdePersoon.Groep.GroepsWerkJaar.Any())
{
// Als er geen groepswerkjaar is, dan is er ook geen lid.
return(null);
}
return
(gelieerdePersoon.Groep.GroepsWerkJaar.OrderByDescending(gwj => gwj.WerkJaar)
.First()
.Lid.Where(ld => !ld.NonActief)
.FirstOrDefault(ld => ld.GelieerdePersoon.ID == gelieerdePersoon.ID));
}
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);
}
