/// <summary>
/// Zoekt adres op, op basis van de parameters.
/// Als er zo geen adres bestaat, wordt het aangemaakt, op
/// voorwaarde dat de straat en subgemeente geidentificeerd
/// kunnen worden. Als ook dat laatste niet het geval is,
/// wordt een exception gethrowd.
/// </summary>
/// <param name="adresInfo">
/// Bevat de gegevens van het te zoeken/maken adres
/// </param>
/// <param name="adressen">
/// Lijst met bestaande adressen om na te kijken of het nieuwe adres al bestaat
/// </param>
/// <param name="straatNamen">queryable voor alle beschikbare straatnamen</param>
/// <param name="woonPlaatsen">queryable voor alle beschikbare woonplaatsen</param>
/// <param name="landen">queryable voor alle beschikbare landen</param>
/// <returns>
/// Gevonden adres
/// </returns>
/// <remarks>
/// Ieder heeft het recht adressen op te zoeken.
/// Voor een Belgisch adres levert het zoeken ook een resultaat op als enkel de woonplaats
/// verschilt. De combinatie straat-postnummer is immers uniek.
/// Omdat ik er niet zeker van ben of je dat in het buitenland ook mag doen, neem ik daar
/// de woonplaats wel mee in de zoekquery. Fusiegemeenten lijkt me vooral iets Belgisch.
/// </remarks>
public Adres ZoekenOfMaken(AdresInfo adresInfo, IQueryable <Adres> adressen, IQueryable <StraatNaam> straatNamen,
IQueryable <WoonPlaats> woonPlaatsen, IQueryable <Land> landen)
{
// In volgorde: Belgisch adres, buitenlands adres, nieuw adres
// Voor een Belgisch adres levert het zoeken ook een resultaat op als enkel de woonplaats
// verschilt. De combinatie straat-postnummer is immers uniek.
// Omdat ik er niet zeker van ben of je dat in het buitenland ook mag doen, neem ik daar
// de woonplaats wel mee in de zoekquery. Fusiegemeenten lijkt me vooral iets Belgisch.
return((from adr in adressen.OfType <BelgischAdres>()
where adr.StraatNaam.Naam == adresInfo.StraatNaamNaam &&
adr.StraatNaam.PostNummer == adresInfo.PostNr &&
adr.HuisNr == adresInfo.HuisNr &&
(adr.Bus ?? String.Empty) == (adresInfo.Bus ?? String.Empty)
// (de truuk met het vraagteken converteert null naar empty voor vergelijken)
select adr).FirstOrDefault() ?? ((from adr in adressen.OfType <BuitenLandsAdres>()
where adr.Straat == adresInfo.StraatNaamNaam &&
adr.HuisNr == adresInfo.HuisNr &&
adr.WoonPlaats == adresInfo.WoonPlaatsNaam &&
(adr.Bus ?? String.Empty) == (adresInfo.Bus ?? String.Empty) &&
adr.Land.Naam == adresInfo.LandNaam &&
adr.PostCode == adresInfo.PostCode
select adr).FirstOrDefault() ??
Maken(adresInfo, straatNamen, woonPlaatsen, landen)));
}
public GroepsAdresModel()
{
// Maak een leeg adres, zodat alle members van IAdresBewerkenModel
// iets opleveren. (Vermijd null exceptions)
Adres = new AdresInfo();
}
public void ZoekenOfMakenBusTest2()
{
// ARRANGE
var adres = new BelgischAdres
{
ID = 1,
StraatNaam = new StraatNaam {
Naam = "Kipdorp", PostNummer = 2000
},
HuisNr = 30,
Bus = null,
WoonPlaats = new WoonPlaats {
Naam = "Antwerpen", PostNummer = 2000
}
};
// ACT
var target = Factory.Maak <AdressenManager>();
var adresInfo = new AdresInfo
{
StraatNaamNaam = adres.StraatNaam.Naam,
HuisNr = adres.HuisNr,
Bus = "",
PostNr = adres.StraatNaam.PostNummer,
WoonPlaatsNaam = adres.WoonPlaats.Naam
};
var adressen = new List <Adres> {
adres
}.AsQueryable();
var straatNamen = new List <StraatNaam> {
adres.StraatNaam
}.AsQueryable();
var woonPlaatsen = new List <WoonPlaats> {
adres.WoonPlaats
}.AsQueryable();
var landen = new List <Land>().AsQueryable();
var actual = target.ZoekenOfMaken(adresInfo, adressen, straatNamen, woonPlaatsen, landen);
// ASSERT
Assert.AreEqual(adres, actual);
}
public void PlaatsBewaren(int uitstapId, string plaatsNaam, AdresInfo adresInfo)
{
var uitstap = _uitstappenRepo.ByID(uitstapId);
Gav.Check(uitstap);
var groep = uitstap.GroepsWerkJaar.Groep;
// zoek of maak adres
var adres = _adressenMgr.ZoekenOfMaken(adresInfo, _adressenRepo.Select(), _straatNamenRepo.Select(), _woonPlaatsenRepo.Select(), _landenRepo.Select());
// zoek plaats
var plaats = (from p in adres.BivakPlaats
where String.Equals(p.Naam, plaatsNaam, StringComparison.OrdinalIgnoreCase) &&
Equals(p.Groep, groep)
select p).FirstOrDefault();
if (plaats == null)
{
// als niet gevonden: maak
plaats = new Plaats {
Naam = plaatsNaam, Adres = adres, Groep = groep
};
groep.BivakPlaats.Add(plaats);
adres.BivakPlaats.Add(plaats);
}
// koppelen
uitstap.Plaats = plaats;
plaats.Uitstap.Add(uitstap);
#if KIPDORP
using (var tx = new TransactionScope())
{
#endif
if (uitstap.IsBivak)
{
_bivakSync.Bewaren(uitstap);
}
_uitstappenRepo.SaveChanges();
#if KIPDORP
tx.Complete();
}
#endif
}
/// <summary>
/// Maakt een nieuw adres op basis van de info in <paramref name="adresInfo"/>, en persisteert
/// </summary>
/// <param name="adresInfo">
/// Gegevens voor het nieuwe adres
/// </param>
/// <param name="straatNamen">beschikbare straatnamen als queryable</param>
/// <param name="woonPlaatsen">beschikbare woonplaatsen als queryable</param>
/// <param name="landen">beschikbare landen als queryable</param>
/// <returns>
/// Het nieuw gemaakte adres
/// </returns>
/// <remarks>
/// TODO: Dit ziet er een veel te ingewikkelde method uit. Best eens refactoren.
/// </remarks>
private Adres Maken(AdresInfo adresInfo, IQueryable <StraatNaam> straatNamen,
IQueryable <WoonPlaats> woonPlaatsen, IQueryable <Land> landen)
{
var problemen = new Dictionary <string, FoutBericht>();
// Al maar preventief een collectie fouten verzamelen. Als daar uiteindelijk
// geen foutberichten in zitten, dan is er geen probleem. Anders
// creëer ik een exception.
// FIXME: de manier waarop de problemen worden doorgegeven, is niet erg proper.
// Kan dat niet eleganter?
if (adresInfo.StraatNaamNaam == string.Empty)
{
problemen.Add("StraatNaamNaam",
new FoutBericht
{
FoutNummer = FoutNummer.StraatOntbreekt,
Bericht = string.Format(
Resources.StraatOntbreekt,
adresInfo.StraatNaamNaam,
adresInfo.PostNr)
});
}
// Controle formaat postnummer enkel voor Belgische adressen.
if ((string.IsNullOrEmpty(adresInfo.LandNaam) ||
String.Compare(adresInfo.LandNaam, Resources.Belgie, StringComparison.OrdinalIgnoreCase) == 0) &&
(adresInfo.PostNr < 1000 || adresInfo.PostNr > 9999))
{
problemen.Add("PostNr",
new FoutBericht
{
FoutNummer = FoutNummer.OngeldigPostNummer,
Bericht = string.Format(
Resources.OngeldigPostNummer,
adresInfo.StraatNaamNaam,
adresInfo.PostNr)
});
}
if (adresInfo.WoonPlaatsNaam == string.Empty)
{
problemen.Add("WoonPlaatsNaam",
new FoutBericht
{
FoutNummer = FoutNummer.WoonPlaatsOntbreekt,
Bericht = string.Format(
Resources.WoonPlaatsOntbreekt,
adresInfo.StraatNaamNaam,
adresInfo.PostNr)
});
}
// Als er hier al fouten zijn: gewoon throwen. Me hiel 't stad, mor ni me maa!
if (problemen.Count != 0)
{
throw new OngeldigObjectException(problemen);
}
Adres adr;
if (string.IsNullOrEmpty(adresInfo.LandNaam) ||
String.Compare(adresInfo.LandNaam, Resources.Belgie, StringComparison.OrdinalIgnoreCase) == 0)
{
// Belgisch adres. Zoek en koppel straat en gemeente
adr = new BelgischAdres();
var s = (from strt in straatNamen
where
String.Compare(adresInfo.StraatNaamNaam, strt.Naam,
StringComparison.OrdinalIgnoreCase) == 0 &&
adresInfo.PostNr == strt.PostNummer
select strt).FirstOrDefault();
if (s != null)
{
// Straat gevonden: aan adres koppelen
((BelgischAdres)adr).StraatNaam = s;
s.BelgischAdres.Add((BelgischAdres)adr);
}
else
{
// Straat niet gevonden: foutbericht toevoegen
problemen.Add("StraatNaamNaam",
new FoutBericht
{
FoutNummer = FoutNummer.StraatNietGevonden,
Bericht = string.Format(
Resources.StraatNietGevonden,
adresInfo.StraatNaamNaam,
adresInfo.PostNr)
});
}
var sg = (from wpl in woonPlaatsen
where
String.Compare(adresInfo.WoonPlaatsNaam, wpl.Naam,
StringComparison.OrdinalIgnoreCase) == 0 &&
adresInfo.PostNr == wpl.PostNummer
select wpl).FirstOrDefault();
if (sg != null)
{
// Gemeente gevonden: aan adres koppelen
((BelgischAdres)adr).WoonPlaats = sg;
sg.BelgischAdres.Add((BelgischAdres)adr);
}
else
{
// Gemeente niet gevonden: foutbericht toevoegen
problemen.Add("WoonPlaatsNaam",
new FoutBericht
{
FoutNummer = FoutNummer.WoonPlaatsNietGevonden,
Bericht = Resources.GemeenteNietGevonden
});
}
}
else
{
// Buitenlands adres. Straat en gemeente zijn gewone strings.
// Zoek en koppel land.
adr = new BuitenLandsAdres();
((BuitenLandsAdres)adr).Straat = adresInfo.StraatNaamNaam;
((BuitenLandsAdres)adr).WoonPlaats = adresInfo.WoonPlaatsNaam;
((BuitenLandsAdres)adr).PostCode = adresInfo.PostCode;
Land l = (from lnd in landen
where String.Compare(lnd.Naam, adresInfo.LandNaam, StringComparison.OrdinalIgnoreCase) == 0
select lnd).FirstOrDefault();
if (l != null)
{
// Gemeente gevonden: aan adres koppelen
((BuitenLandsAdres)adr).Land = l;
l.BuitenLandsAdres.Add((BuitenLandsAdres)adr);
}
else
{
// Gemeente niet gevonden: foutbericht toevoegen
problemen.Add("LandNaam",
new FoutBericht
{
FoutNummer = FoutNummer.LandNietGevonden,
Bericht = Resources.LandNietGevonden
});
}
}
if (problemen.Count != 0)
{
throw new OngeldigObjectException(problemen);
}
adr.HuisNr = adresInfo.HuisNr;
adr.Bus = adresInfo.Bus;
// bewaren brengt Versie en ID automatisch in orde.
return(adr);
}
