public void ToekennenFunctieOngeldigWerkJaar()
        {
            // ARRANGE

            var groepsWerkJaar = new GroepsWerkJaar
            {
                Groep    = new ChiroGroep(),
                WerkJaar = 2012
            };

            groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
            var lid = new Leiding {
                GroepsWerkJaar = groepsWerkJaar
            };

            var vervallenFunctie = new Functie
            {
                WerkJaarTot = groepsWerkJaar.WerkJaar - 1,
                MinAantal   = 1,
                Groep       = groepsWerkJaar.Groep,
                Niveau      = Niveau.Groep
            };

            var functiesManager = Factory.Maak <FunctiesManager>();

            // ASSERT

            Assert.Throws <FoutNummerException>(() => functiesManager.Toekennen(lid, new List <Functie> {
                vervallenFunctie
            }));

            // Als er geen exception gethrowd worden, zal de test failen.
        }
        public void ContactZonderEmail()
        {
            // ARRANGE

            var groepsWerkJaar = new GroepsWerkJaar {
                Groep = new ChiroGroep(), WerkJaar = 2012
            };

            groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);

            var contactPersoonFunctie = new Functie
            {
                ID          = (int)NationaleFunctie.ContactPersoon,
                MinAantal   = 1,
                IsNationaal = true,
                Niveau      = Niveau.LeidingInGroep,
            };
            var lid = new Leiding
            {
                GroepsWerkJaar   = groepsWerkJaar,
                GelieerdePersoon = new GelieerdePersoon()
            };

            var functiesManager = Factory.Maak <FunctiesManager>();
            // ASSERT

            var ex = Assert.Throws <FoutNummerException>(
                () => functiesManager.Toekennen(lid, new List <Functie> {
                contactPersoonFunctie
            }));

            Assert.AreEqual(FoutNummer.EMailVerplicht, ex.FoutNummer);
        }
Ejemplo n.º 3
0
        public TotemEntryRepositoryTest()
        {
            _adjective = new Adjectief
            {
                Naam = "Wijze"
            };

            _totem = new Totem
            {
                Naam = "Nachtegaal"
            };

            _leader1 = new Leiding
            {
                Naam     = "pierlala",
                Voornaam = "Jantje"
            };

            _leader2 = new Leiding
            {
                Naam     = "Lothbrok",
                Voornaam = "Ragnar"
            };

            _dbContext = CreateDbContext();

            _dbContext.Adjectieven.Add(_adjective);
            _dbContext.Leiding.Add(_leader1);
            _dbContext.Leiding.Add(_leader2);
            _dbContext.Totems.Add(_totem);
            _dbContext.SaveChanges();
        }
        public void FunctieDitJaarInGebruikVerwijderenTest()
        {
            // arrange

            // testsituatie creeren
            var functie        = new Functie();
            var groepswerkjaar = new GroepsWerkJaar
            {
                ID    = 11,
                Groep =
                    new ChiroGroep
                {
                    ID             = 1,
                    GroepsWerkJaar = new List <GroepsWerkJaar>()
                }
            };

            groepswerkjaar.Groep.GroepsWerkJaar.Add(groepswerkjaar);
            functie.Groep = groepswerkjaar.Groep;
            var lid = new Leiding {
                Functie = new List <Functie>()
                {
                    functie
                }, GroepsWerkJaar = groepswerkjaar
            };

            functie.Lid.Add(lid);

            var mgr = Factory.Maak <FunctiesManager>();

            // assert

            Assert.Throws <BlokkerendeObjectenException <Lid> >(() => mgr.Verwijderen(functie, false));
        }
Ejemplo n.º 5
0
 public static Order Create(Leiding orderedBy)
 {
     return(new Order()
     {
         OrderedBy = orderedBy,
         CreatedOn = DateTime.Now.ToLocalTime()
     });
 }
Ejemplo n.º 6
0
        public void WerkjaarVerzekeringGeenOverlap()
        {
            // ARRANGE
            var groepsWerkJarenManager = Factory.Maak <IGroepsWerkJarenManager>();

            var vtype = new VerzekeringsType
            {
                TotEindeWerkJaar = true
            };

            var groepsWerkJaar = new GroepsWerkJaar
            {
                Groep    = new ChiroGroep(),
                WerkJaar = 2012
            };
            var vorigGroepsWerkJaar = new GroepsWerkJaar
            {
                Groep    = new ChiroGroep(),
                WerkJaar = 2011
            };

            groepsWerkJaar.Groep.GroepsWerkJaar.Add(groepsWerkJaar);
            groepsWerkJaar.Groep.GroepsWerkJaar.Add(vorigGroepsWerkJaar);

            var persoon = new Persoon
            {
                PersoonsVerzekering = new List <PersoonsVerzekering>
                {
                    new PersoonsVerzekering
                    {
                        VerzekeringsType = vtype,
                        Van = new DateTime(2011, 10, 1),
                        // De einddatum moeten we via de groepsWerkJarenManager laten
                        // berekenen, want het einde van een groepswerkjaar valt bijv.
                        // anders bij staging als bij dev.
                        Tot = groepsWerkJarenManager.EindDatum(vorigGroepsWerkJaar)
                    }
                }
            };

            var lid1 = new Leiding
            {
                GroepsWerkJaar   = groepsWerkJaar,
                GelieerdePersoon = new GelieerdePersoon {
                    Persoon = persoon
                }
            };

            // ACT

            var verzekeringenManager = Factory.Maak <VerzekeringenManager>();

            verzekeringenManager.Verzekeren(lid1, vtype, new DateTime(2012, 10, 1), groepsWerkJarenManager.EindDatum(groepsWerkJaar));

            // ASSERT

            Assert.AreEqual(2, persoon.PersoonsVerzekering.Count);
        }
        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);
        }
Ejemplo n.º 8
0
        public async Task Cant_Place_Order_If_OrderedFor_Section_Cant_Use_Tab()
        {
            var section = new Tak()
            {
                TabIsAllowed = false
            };
            var person = new Leiding()
            {
                Tak = section
            };
            var account = new Account(AccountType.Tab);

            person.Accounts = new List <Account> {
                account
            };


            var order     = Order.Create(person);
            var orderline = Orderline.Create(_defaultDrank, person, order, 1);

            var orderRepository = new Mock <IOrderRepository>();
            var leidingRepo     = new Mock <ILeidingRepository>();

            leidingRepo.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).Returns(Task.FromResult <Leiding>(person));
            leidingRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Leiding>(person));
            var drankRepo = new Mock <IDrankRepository>();

            drankRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Drank>(_defaultDrank));
            var orderlineRepo = new Mock <IOrderlineRepository>();

            var accountRepo = new Mock <IAccountRepository>();

            accountRepo.Setup(x => x.FindAccountAsync(It.IsAny <int>(), AccountType.Tab))
            .Returns(Task.FromResult <Account>(account));

            var accountService = new Mock <IAccountService>();

            var service = new OrderService(orderRepository.Object, leidingRepo.Object, drankRepo.Object, orderlineRepo.Object, accountRepo.Object, accountService.Object);

            var orderlines = new List <CreateOrderlineDTO>();

            orderlines.Add(item: new CreateOrderlineDTO
            {
                DrankId      = 10,
                OrderedForId = 10,
                Quantity     = 10
            });

            var orderDto = new CreateOrderDTO()
            {
                Orderlines = orderlines
            };


            await Assert.ThrowsAsync <InvalidOperationException>(() => service.CreateOrder(orderDto, String.Empty));
        }
        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 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));
        }
Ejemplo n.º 11
0
        public void NooitAangeslotenLedenAansluitenTest()
        {
            // ARRANGE
            const int huidigWerkjaar  = 2014;
            DateTime  vandaagZoGezegd = new DateTime(2015, 02, 23);

            // We hebben 1 leidster, die niet meer in haar probeerperiode zit.
            var leidster = new Leiding
            {
                ID = 1,
                EindeInstapPeriode = vandaagZoGezegd.AddDays(-7),
                GelieerdePersoon   = new GelieerdePersoon
                {
                    ID      = 2,
                    Persoon = new Persoon
                    {
                        ID       = 3,
                        VoorNaam = "Kelly",
                        Naam     = "Pfaff"
                    }
                },
                GroepsWerkJaar = new GroepsWerkJaar
                {
                    ID       = 4,
                    WerkJaar = huidigWerkjaar,
                    Groep    = new ChiroGroep {
                        ID = 5
                    }
                }
            };

            leidster.GroepsWerkJaar.Groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
                leidster.GroepsWerkJaar
            };

            // ACT
            var target = new LedenManager();
            var result = target.AanTeSluitenLedenOphalen((new List <Lid> {
                leidster
            }).AsQueryable(), huidigWerkjaar,
                                                         vandaagZoGezegd, null);

            // ASSERT
            Assert.IsNotEmpty(result);
        }
Ejemplo n.º 12
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);
        }
Ejemplo n.º 13
0
        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 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);
        }
Ejemplo n.º 15
0
        public async Task <BasicLeaderDTO> CreateLeader(CreateLeaderDTO dto)
        {
            //Check if a section is provided for the leader
            Tak tak = null;

            if (dto.TakId != 0)
            {
                tak = await _takRepository.FindByIdAsync(dto.TakId);

                if (tak == null)
                {
                    throw new EntityNotFoundException($"Tak met id {dto.TakId} werd niet gevonden.");
                }
            }


            //Map the dto to the leader entity. TODO: This smells fishy. I don't like new()
            var leader = new Leiding
            {
                Naam         = dto.Naam.Trim(),
                Voornaam     = dto.Voornaam.Trim(),
                LeidingSinds = dto.LeidingSinds.ToLocalTime(),
                Tak          = tak,
                Email        = dto.Email?.Trim().ToLower(),
                Accounts     = new List <Account>(2)
            };

            //Only create accounts if needed. E.g.: leaders created through the totemdatabase probably shouldn't have an account at first.
            if (dto.CreateAccounts)
            {
                leader.Accounts.Add(new Account(AccountType.Debt));
                leader.Accounts.Add(new Account(AccountType.Tab));
            }


            await _leidingRepository.AddAsync(leader);

            await _leidingRepository.SaveChangesAsync();

            return(_mapper.Map <BasicLeaderDTO>(leader));
        }
        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 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
            }));
        }
Ejemplo n.º 18
0
        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 OrderlineTest()
 {
     _drank   = Drank.Create(_naam, _prijs, _type, _inStock);
     _leiding = new Leiding();
     _order   = Order.Create(_leiding);
 }
Ejemplo n.º 20
0
        /// <summary>
        /// Maakt een gelieerde persoon <paramref name="gp"/> lid in groepswerkjaar <paramref name="gwj"/>,
        /// met lidtype <paramref name="type"/>, persisteert niet.
        /// </summary>
        /// <param name="gp">
        /// Lid te maken gelieerde persoon, gekoppeld met groep en persoon
        /// </param>
        /// <param name="gwj">
        /// Groepswerkjaar waarin de gelieerde persoon lid moet worden
        /// </param>
        /// <param name="type">
        /// LidType.Kind of LidType.Leiding
        /// </param>
        /// <param name="isJaarOvergang">
        /// Als deze true is, is einde probeerperiode steeds
        /// 15 oktober als het nog geen 15 oktober is
        /// </param>
        /// <remarks>
        /// Private; andere lagen moeten via 'Inschrijven' gaan.
        /// <para>
        /// </para>
        /// Deze method test niet of het groepswerkjaar wel het recentste is.  (Voor de unit tests moeten
        /// we ook leden kunnen maken in oude groepswerkjaren.)
        /// Roep deze method ook niet rechtstreeks aan, maar wel via KindMaken of LeidingMaken
        /// </remarks>
        /// <returns>
        /// Het aangepaste Lid-object
        /// </returns>
        /// <throws>FoutNummerException</throws>
        /// <throws>GeenGavException</throws>
        /// <throws>InvalidOperationException</throws>
        private Lid LidMaken(GelieerdePersoon gp, GroepsWerkJaar gwj, LidType type, bool isJaarOvergang)
        {
            Lid lid;

            switch (type)
            {
            case LidType.Kind:
                lid = new Kind();
                break;

            case LidType.Leiding:
                lid = new Leiding();
                break;

            default:
                lid = new Lid();
                break;
            }

            // GroepsWerkJaar en GelieerdePersoon invullen
            lid.GroepsWerkJaar   = gwj;
            lid.GelieerdePersoon = gp;
            gp.Lid.Add(lid);
            gwj.Lid.Add(lid);

            var stdProbeerPeriode = DateTime.Today.AddDays(Settings.Default.LengteProbeerPeriode);

            var eindeJaarOvergang = Settings.Default.WerkjaarVerplichteOvergang;

            eindeJaarOvergang = new DateTime(gwj.WerkJaar, eindeJaarOvergang.Month, eindeJaarOvergang.Day);

            if ((gp.Groep.Niveau & (Niveau.Gewest | Niveau.Verbond)) != 0)
            {
                lid.EindeInstapPeriode = DateTime.Today;
            }
            else if (!isJaarOvergang)
            {
                // Standaardinstapperiode indien niet in jaarovergang
                lid.EindeInstapPeriode = eindeJaarOvergang >= stdProbeerPeriode
                                             ? eindeJaarOvergang
                                             : stdProbeerPeriode;
            }
            else
            {
                // Voor jaarovergang: vaste deadline (gek idee, maar blijkbaar in de specs)
                lid.EindeInstapPeriode = eindeJaarOvergang >= DateTime.Now
                                             ? eindeJaarOvergang
                                             : stdProbeerPeriode;
            }

            FoutNummer?fout = new LidValidator().FoutNummer(lid);

            if (fout == FoutNummer.GroepsWerkJaarNietVanGroep)
            {
                throw new FoutNummerException(FoutNummer.GroepsWerkJaarNietVanGroep,
                                              Resources.GroepsWerkJaarNietVanGroep);
            }

            // Geboortedatum is verplicht als je lid wilt worden
            if (fout == FoutNummer.GeboorteDatumOntbreekt)
            {
                throw new FoutNummerException(FoutNummer.GeboorteDatumOntbreekt, Resources.GeboorteDatumOntbreekt);
            }

            // Je moet oud genoeg zijn
            if (fout == FoutNummer.LidTeJong)
            {
                throw new FoutNummerException(FoutNummer.LidTeJong, Resources.MinimumLeeftijd);
            }

            // en nog leven ook
            if (fout == FoutNummer.PersoonOverleden)
            {
                throw new FoutNummerException(FoutNummer.PersoonOverleden, Resources.PersoonIsOverleden);
            }


            return(lid);
        }
Ejemplo n.º 21
0
        public void LedenInProbeerPeriodeNietSyncen()
        {
            // ARRANGE

            const int huidigWerkjaar  = 2014;
            DateTime  vandaagZoGezegd = new DateTime(2015, 02, 23);

            // We hebben 1 leidster, die nog in haar probeerperiode zit.
            var leidster = new Leiding
            {
                ID = 1,
                EindeInstapPeriode = vandaagZoGezegd.AddDays(7),
                GelieerdePersoon   = new GelieerdePersoon
                {
                    ID      = 2,
                    Persoon = new Persoon
                    {
                        ID       = 3,
                        VoorNaam = "Kelly",
                        Naam     = "Pfaff"
                    }
                },
                GroepsWerkJaar = new GroepsWerkJaar
                {
                    ID       = 4,
                    WerkJaar = huidigWerkjaar
                }
            };

            // De repository bevat enkel deze leidster.
            var ledenRepo = new DummyRepo <Lid>(new List <Lid> {
                leidster
            });

            // Repositoryprovidermock opzetten
            var repoProviderMock = new Mock <IRepositoryProvider>();

            repoProviderMock.Setup(src => src.RepositoryGet <Lid>()).Returns(ledenRepo);

            // Mock voor personenSync
            var personenSyncMock = new Mock <IPersonenSync>();

            personenSyncMock.Setup(
                src =>
                src.MembershipRegistreren(It.Is <Lid>(l => l.ID == leidster.ID))).Verifiable();

            // Meer mocks.
            var groepsWerkJaarManagerMock = new Mock <IGroepsWerkJarenManager>();

            groepsWerkJaarManagerMock.Setup(src => src.HuidigWerkJaarNationaal()).Returns(huidigWerkjaar);
            groepsWerkJaarManagerMock.Setup(src => src.Vandaag()).Returns(vandaagZoGezegd);

            // Mocks registeren
            Factory.InstantieRegistreren(repoProviderMock.Object);
            Factory.InstantieRegistreren(personenSyncMock.Object);
            Factory.InstantieRegistreren(groepsWerkJaarManagerMock.Object);

            // ACT

            var target = Factory.Maak <MembershipMaintenance>();

            target.MembershipsMaken();

            // ASSERT

            personenSyncMock.Verify(
                src => src.MembershipRegistreren(It.Is <Lid>(l => l.ID == leidster.ID)), Times.Never);
        }
Ejemplo n.º 22
0
        public void VanGratisNaarBetalendMembershipTest()
        {
            // ARRANGE
            const int huidigWerkjaar  = 2015;
            DateTime  vandaagZoGezegd = new DateTime(2016, 1, 7);

            var gewest = new KaderGroep {
                ID = 6
            };

            // We hebben 1 leidster, die ook in het gewest actief is.
            var leidster = new Leiding
            {
                ID = 1,
                EindeInstapPeriode = vandaagZoGezegd.AddDays(-7),
                GelieerdePersoon   = new GelieerdePersoon
                {
                    ID      = 2,
                    Persoon = new Persoon
                    {
                        ID       = 3,
                        VoorNaam = "Kelly",
                        Naam     = "Pfaff"
                    }
                },
                GroepsWerkJaar = new GroepsWerkJaar
                {
                    ID       = 4,
                    WerkJaar = huidigWerkjaar,
                    Groep    = new ChiroGroep {
                        ID = 5
                    }
                }
            };

            leidster.GroepsWerkJaar.Groep.GroepsWerkJaar = new List <GroepsWerkJaar> {
                leidster.GroepsWerkJaar
            };

            leidster.GelieerdePersoon.Persoon.GelieerdePersoon.Add(new GelieerdePersoon
            {
                ID    = 5,
                Groep = gewest,
                Lid   = new [] { new Leiding
                                 {
                                     ID             = 7,
                                     IsAangesloten  = true,
                                     GroepsWerkJaar = new GroepsWerkJaar
                                     {
                                         ID       = 8,
                                         WerkJaar = huidigWerkjaar,
                                         Groep    = gewest
                                     }
                                 } }
            });

            // ACT
            var target = new LedenManager();
            var result = target.AanTeSluitenLedenOphalen((new List <Lid> {
                leidster
            }).AsQueryable(), huidigWerkjaar,
                                                         vandaagZoGezegd, null);

            // ASSERT
            Assert.IsNotEmpty(result);
        }
        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);
        }