public bool New(Partij p)
 {
     try
     {
         Database.Conn.Open();
         string query = "INSERT INTO Partij (Afkorting, Naam, Zetels, LijsttrekkerID) VALUES (@afk, @naam, @zetels, @lijsttrekker)";
         using (SqlCommand cmd = new SqlCommand(query, Database.Conn))
         {
             cmd.Parameters.AddWithValue("@afk", p.Afkorting);
             cmd.Parameters.AddWithValue("@naam", p.Naam);
             cmd.Parameters.AddWithValue("@zetels", p.Zetels);
             cmd.Parameters.AddWithValue("@lijsttrekker", p.LijsttrekkerId);
             cmd.ExecuteNonQuery();
             return(true);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.ToString());
         return(false);
     }
     finally
     {
         Database.Conn.Close();
     }
 }
 public bool Update(Partij p)
 {
     try
     {
         Database.Conn.Open();
         string query = "UPDATE Partij SET Afkorting = @afk, Naam = @naam, Zetels = @zetels, LijsttrekkerID = @lijsttrekkerid";
         using (SqlCommand cmd = new SqlCommand(query, Database.Conn))
         {
             cmd.Parameters.AddWithValue("@afk", p.Afkorting);
             cmd.Parameters.AddWithValue("@naam", p.Naam);
             cmd.Parameters.AddWithValue("@zetels", p.Zetels);
             cmd.Parameters.AddWithValue("@lijsttrekkerid", p.LijsttrekkerId);
             cmd.ExecuteNonQuery();
             return(true);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.ToString());
         return(false);
     }
     finally
     {
         Database.Conn.Close();
     }
 }
        public async Task GetAllPartijenFromGebruikerByGebruikerIdTestMetMockServiceSuccesvol()
        {
            var testResult = new PartijenCollectie(new List<Partij> { new Partij { Id = 1 }, new Partij { Id = 2 } }, new List<Partij> { new Partij { Id = 3 }, new Partij { Id = 4 } });
            //arrange
            var mockService = new Mock<IPartijService>();
            mockService.Setup(x => x.GetPartijenFromGebruikerByGebruikerId(1)).ReturnsAsync(testResult).Verifiable();
            var controller = new PartijController(mockService.Object, null);

            //Act
            var result = await controller.GetAllPartijenFromGebruikerByGebruikerId(1) as ObjectResult;
            var result2 = await controller.GetAllPartijenFromGebruikerByGebruikerId(2) as ObjectResult;
            var _result = result.Value as PartijenCollectie;
            var _result2 = result2.Value as PartijenCollectie;
            Console.WriteLine(result);
            //Assert
            Assert.AreEqual(200, result.StatusCode);
            Assert.AreEqual(200, result2.StatusCode);
            Assert.IsNotNull(_result);
            Assert.IsNull(_result2);
            Assert.AreEqual(2, _result.PartijenDieAfgelopenZijn.Count);
            Assert.AreEqual(2, _result.PartijenDieNogBezigZijn.Count);
            var testpartij = new Partij { Id = 1 };
            IList<Partij> iList = _result.PartijenDieAfgelopenZijn as IList<Partij>;
            Assert.AreEqual(testpartij.Id, iList[0].Id);
        }
Example #4
0
        private List <Partij> CreatePartijFromLv()
        {
            List <Partij> selectedPartijen = new List <Partij>();

            foreach (ListViewItem item in listView.CheckedItems)
            {
                Partij partij = new Partij();
                partij.Afkorting = item.Text;
                partij.Naam      = item.SubItems[1].Text.ToString();
                foreach (Lid l in leden)
                {
                    if (l.Naam == item.SubItems[2].Text.ToString())
                    {
                        partij.LijsttrekkerId = l.Id;
                    }
                }
                partij.Zetels = Convert.ToInt32(item.SubItems[3].Text);
                foreach (Partij p in partijen)
                {
                    if (p.Afkorting == partij.Afkorting)
                    {
                        partij.Id = p.Id;
                    }
                }
                selectedPartijen.Add(partij);
            }
            return(selectedPartijen);
        }
Example #5
0
        //GET BY ID
        //Haal de partij op met het gegeven id
        public Partij GetPartijByID(int id)
        {
            Partij partij;

            using (SqlConnection conn = Database.Connection)
            {
                string query = "SELECT * FROM Partij WHERE ID = @ID";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    cmd.Parameters.AddWithValue("@ID", id);
                    using (SqlDataReader rd = cmd.ExecuteReader())
                    {
                        while (rd.Read())
                        {
                            string Naam         = Convert.ToString(rd["Naam"]);
                            string Lijsttrekker = Convert.ToString(rd["Lijsttrekker"]);

                            partij = new Partij(Naam, Lijsttrekker);
                            return(partij);
                        }
                    }
                }
                return(null);
            }
        }
Example #6
0
        public async Task UpdatePartij(Partij partijDieGeupdateMoetWorden, Partij partij)
        {
            partijDieGeupdateMoetWorden.TijdWitSpeler   = partij.TijdWitSpeler;
            partijDieGeupdateMoetWorden.TijdZwartSpeler = partij.TijdZwartSpeler;
            partijDieGeupdateMoetWorden.Uitslag         = partij.Uitslag;
            if (partijDieGeupdateMoetWorden.Uitslag != partij.Uitslag)
            {
                GebruikerService _service = new GebruikerService(_gebruikerRepository);
                var spelers = await _spelerRepository.GetAllSpelersWithPartijByPartijId(partijDieGeupdateMoetWorden.Id) as List <Speler>;

                var witSpeler   = new Speler();
                var zwartSpeler = new Speler();
                foreach (Speler speler in spelers)
                {
                    if (speler.KleurSpeler == "wit")
                    {
                        witSpeler = speler;
                    }
                    else
                    {
                        zwartSpeler = speler;
                    }
                }
                foreach (Speler speler in spelers)
                {
                    var gebruiker = await _gebruikerRepository.GetGebruikerByGebruikerId(speler.GebruikerId);

                    await _service.UpdateGebruiker(gebruiker, new Gebruiker { Id = gebruiker.Id, Gebruikersnaam = gebruiker.Gebruikersnaam, Email = gebruiker.Email, Rating = gebruiker.Rating + BerekenRatingVerschil(witSpeler.RatingAanBeginVanWedstrijd, zwartSpeler.RatingAanBeginVanWedstrijd, partij.Uitslag, speler.KleurSpeler) });
                }
            }

            await _partijRepository.CommitAsync();
        }
        public void AllePartijenDieAfZijnSorterenTest()
        {
            //arrange
            var testpartij1 = new Partij {
                Id = 1, Uitslag = "0"
            };
            var testpartij2 = new Partij {
                Id = 2, Uitslag = "0-2"
            };
            var testpartij3 = new Partij {
                Id = 3, Uitslag = "0"
            };
            var testpartij4 = new Partij {
                Id = 4, Uitslag = "1-1"
            };
            var testpartij5 = new Partij {
                Id = 5, Uitslag = "0"
            };

            var partijen = new List <Partij> {
                testpartij1, testpartij2, testpartij3, testpartij4, testpartij5
            };

            var service = new PartijService(mockPartijRepository.Object, mockSpelerRepository.Object, mockGebruikerRepository.Object, mockBerichtRepository.Object);

            var result = service.AllePartijenDieAfZijn(partijen) as List <Partij>;

            Assert.IsNotNull(service);
            Assert.IsNotNull(result);
            Assert.AreEqual(2, result.Count);
        }
Example #8
0
        public async Task <Partij> CreatePartij(Partij newPartij)
        {
            await _partijRepository.AddAsync(newPartij);

            await _partijRepository.CommitAsync();

            var partijen = await _partijRepository.GetAllWithZettenAsync() as List <Partij>;

            return(partijen[partijen.Count - 1]);
        }
        public async Task <IActionResult> Create(Partij partij)
        {
            if (ModelState.IsValid)
            {
                _context.Add(partij);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(HomeController.Index), "Home"));
            }
            return(View(partij));
        }
Example #10
0
        private void btnPasPartijAan_Click(object sender, EventArgs e)
        {
            if (lbPartijen.SelectedItem != null)
            {
                gbPartijAanpassen.Enabled = true;

                Partij partij = lbPartijen.SelectedItem as Partij;

                tbPartijNaam.Text   = partij.Naam;
                tbLijsttrekker.Text = partij.Lijsttrekker;
            }
        }
Example #11
0
        static List <Partij> LeesPartijen(string bestand)
        {
            StreamReader reader = new StreamReader(bestand);

            while (!reader.EndOfStream)
            {
                Partij partij = new Partij();
                partij.naam       = reader.ReadLine();
                partij.antwoorden = reader.ReadLine();
                partijen.Add(partij);
            }

            return(partijen);
        }
        public Partij GetById(int id)
        {
            List <Lid> leden = new List <Lid>();
            Partij     p     = new Partij();

            try
            {
                Database.Conn.Open();
                string queryLid = "SELECT * FROM Lid WHERE PartijID = @id";
                using (SqlCommand cmd = new SqlCommand(queryLid, Database.Conn))
                {
                    cmd.Parameters.AddWithValue("@id", id);
                    using (SqlDataReader r = cmd.ExecuteReader())
                    {
                        while (r.Read())
                        {
                            leden.Add(CreateLidFromReader(r));
                        }
                    }
                }

                string queryPartij = "SELECT * FROM Partij WHERE PartijID = @id";
                using (SqlCommand cmd = new SqlCommand(queryPartij, Database.Conn))
                {
                    cmd.Parameters.AddWithValue("@id", id);
                    using (SqlDataReader r = cmd.ExecuteReader())
                    {
                        while (r.Read())
                        {
                            p = CreatePartijFromReader(r);
                        }
                    }
                }
                foreach (Lid l in leden)
                {
                    p.Leden.Add(l);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return(null);
            }
            finally
            {
                Database.Conn.Close();
            }
            return(null);
        }
Example #13
0
 public Party(Partij p)
 {
     InitializeComponent();
     lidRepo           = new LidRepository(new LidSqlContext());
     partijRepo        = new PartijRepository(new PartijSqlContext());
     leden             = lidRepo.GetAll();
     partij            = p;
     lblPartyName.Text = partij.Naam;
     lblPartyAfk.Text  = partij.Afkorting;
     foreach (Lid l in leden)
     {
         if (l.Id == partij.LijsttrekkerId)
         {
             lblPartyRep.Text = lblPartyRep.Text + l.Naam;
         }
     }
     lblSeats.Text = lblSeats.Text + partij.Zetels.ToString();
 }
        public async Task GetPartijByIdTestMetMockServiceSuccesvol()
        {
            var testResult = new Partij{ Id = 1, SpeeltempoMinuten = 60, SpeeltempoFisherSeconden = 60 };
            //arrange
            var mockService = new Mock<IPartijService>();
            mockService.Setup(x => x.GetPartijById(1)).ReturnsAsync(testResult).Verifiable();
            var controller = new PartijController(mockService.Object, null);

            //Act
            var result = await controller.GetPartijById(1) as OkObjectResult;
            var _result = result.Value as Partij;
            Console.WriteLine(result);
            //Assert
            Assert.AreEqual(200, result.StatusCode);
            Assert.AreEqual(1, _result.Id);
            Assert.IsNull(_result.Uitslag);
            Assert.AreEqual(60, _result.SpeeltempoMinuten);
            Assert.AreEqual(60, _result.SpeeltempoFisherSeconden);
        }
Example #15
0
        private void btnBevestigPartij_Click(object sender, EventArgs e)
        {
            if (lbPartijen.SelectedItem != null)
            {
                Partij partij = lbPartijen.SelectedItem as Partij;
                try
                {
                    app.PartijAanpassen(new Partij(partij.ID, tbPartijNaam.Text, tbLijsttrekker.Text));
                    MessageBox.Show("Partij opgeslagen");
                }
                catch (UpdateDatabaseException ex)
                {
                    MessageBox.Show(ex.Message);
                }
                gbPartijAanpassen.Enabled = false;
                LaadtPartijen();
            }
            else
            {
                if (tbPartijNaam.Text != null && tbLijsttrekker.Text != null)
                {
                    string naam         = tbPartijNaam.Text;
                    string lijsttrekker = tbLijsttrekker.Text;

                    try
                    {
                        app.PartijToevoegen(new Partij(naam, lijsttrekker));
                        MessageBox.Show("Partij opgeslagen");
                    }
                    catch (InsertDatabaseException ex)
                    {
                        MessageBox.Show(ex.Message);
                    }

                    //zet de enabled van de knoppen/textboxen uit zodat ze niet ingevuld kunnen worden
                    gbPartijAanpassen.Enabled = false;

                    //herlaadt al de partijen zodat de nieuwe ook in de listbox komt te staan
                    LaadtPartijen();
                }
            }
        }
        // GET: Players/CreateSpecial?playerId=1&day=Saturday
        public IActionResult CreateSpecial(int playerId, Dagen day)
        {
            if (playerId <= 0)
            {
                return(NotFound());
            }
            Player player = this._context.Player.FirstOrDefault(p => p.Id == playerId);

            if (player == null)
            {
                return(NotFound());
            }
            Partij partij = new Partij()
            {
                Player = player, PlayerId = player.Id, Dag = day
            };

            ViewBag.Uitslagen = Enum.GetValues(typeof(Uitslagen));
            return(View(partij));
        }
        // GET: Partijen
        public ActionResult Index()
        {
            PartijenListVM partijenListVM = new PartijenListVM();

            string msg   = "Selecteer een bewerking op een partij of voeg een partij toe";
            string level = partijenListVM.MessageSection.Info;
            string title = "Overzicht P A R T I J E N";

            var q = db.Partijen.ToList();

            if (q.Count == 0)
            {
                level = partijenListVM.MessageSection.Warning;
                msg   = "Geen partijen gevonden";
            }
            else
            {
                foreach (var entry in q)
                {
                    Partij part = new Partij
                    {
                        PartijID   = entry.PartijID.ToUpper(),
                        PartijNaam = entry.PartijNaam
                    };

                    partijenListVM.PartijenLijst.Add(part);
                }
                partijenListVM.MessageSection.SetMessage(title, level, msg);
            }
            if (TempData.ContainsKey("BCmessage"))
            {
                msg = TempData["BCmessage"].ToString();
            }
            if (TempData.ContainsKey("BCerrorlevel"))
            {
                level = TempData["BCerrorlevel"].ToString();
            }
            partijenListVM.MessageSection.SetMessage(title, level, msg);
            return(View(partijenListVM));
        }
Example #18
0
        //INSERTS
        //insert een nieuwe verkiezing in de database
        public bool InsertPartij(Partij partij)
        {
            using (SqlConnection conn = Database.Connection)
            {
                string query = "INSERT INTO Partij(Naam, Lijsttrekker)" +
                               "VALUES(@Naam, @Lijsttrekker)";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    cmd.Parameters.AddWithValue("@Naam", partij.Naam);
                    cmd.Parameters.AddWithValue("@Lijsttrekker", partij.Lijsttrekker);

                    try
                    {
                        cmd.ExecuteNonQuery();
                        return(true);
                    }
                    catch (Exception)
                    {
                        throw new InsertDatabaseException("Er is al een partij aanwezig met de ingevulde gegevens");
                    }
                }
            }
        }
Example #19
0
        //UPDATES
        //
        public bool UpdatePartij(Partij partij)
        {
            using (SqlConnection conn = Database.Connection)
            {
                string query = "UPDATE Partij SET Naam = @Naam, Lijsttrekker = @Lijsttrekker " +
                               "WHERE ID = @ID";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    cmd.Parameters.AddWithValue("@ID", partij.ID);
                    cmd.Parameters.AddWithValue("@Naam", partij.Naam);
                    cmd.Parameters.AddWithValue("@Lijsttrekker", partij.Lijsttrekker);

                    try
                    {
                        cmd.ExecuteNonQuery();
                        return(true);
                    }
                    catch (Exception)
                    {
                        throw new UpdateDatabaseException("Er is een fout opgetreden bij het opslaan, probeer opnieuw");
                    }
                }
            }
        }
 public bool Delete(Partij p)
 {
     try
     {
         Database.Conn.Open();
         //  string query = "DELETE FROM Partij WHERE PartijID = @id";
         using (SqlCommand cmd = new SqlCommand("DeleteParty", Database.Conn))
         {
             cmd.CommandType = System.Data.CommandType.StoredProcedure;
             cmd.Parameters.AddWithValue("@id", p.Id);
             cmd.ExecuteNonQuery();
             return(true);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.ToString());
         return(false);
     }
     finally
     {
         Database.Conn.Close();
     }
 }
Example #21
0
        public async Task GetPartijByIdTestMetMockRepositorySuccesvol()
        {
            var testResultPartijenOpvragen =
                new Partij
            {
                Id = 1,
                SpeeltempoMinuten        = 10,
                SpeeltempoFisherSeconden = 5,
                Uitslag = "1-1",
                Zetten  = new List <Zet> {
                    new Zet {
                        Id        = 1,
                        BeginVeld = 32,
                        EindVeld  = 28
                    },
                    new Zet {
                        Id        = 2,
                        BeginVeld = 19,
                        EindVeld  = 23
                    }
                } as ICollection <Zet>,
                Spelers = new List <Speler> {
                    new Speler {
                        Id          = 1,
                        GebruikerId = 1,
                        KleurSpeler = "Wit",
                        RatingAanBeginVanWedstrijd = 1200
                    },
                    new Speler {
                        Id          = 2,
                        GebruikerId = 2,
                        KleurSpeler = "Zwart",
                        RatingAanBeginVanWedstrijd = 1200
                    }
                } as ICollection <Speler>
            };

            var gebruiker1 = new Gebruiker {
                Id = 1, Gebruikersnaam = "pimm32", Rating = 1500
            };
            var gebruiker2 = new Gebruiker {
                Id = 2, Gebruikersnaam = "Karbonkel", Rating = 1350
            };
            //arrange
            var mockPartijRepository    = new Mock <IPartijRepository>();
            var mockGebruikerRepository = new Mock <IGebruikerRepository>();

            mockPartijRepository.Setup(x => x.GetWithZettenByIdAsync(1)).ReturnsAsync(testResultPartijenOpvragen).Verifiable();
            mockGebruikerRepository.Setup(x => x.GetGebruikerByGebruikerId(1)).ReturnsAsync(gebruiker1).Verifiable();
            mockGebruikerRepository.Setup(x => x.GetGebruikerByGebruikerId(2)).ReturnsAsync(gebruiker2).Verifiable();
            var service = new PartijService(mockPartijRepository.Object, mockSpelerRepository.Object, mockGebruikerRepository.Object, mockBerichtRepository.Object);


            //Act
            var result = await service.GetPartijById(1) as Partij;

            //Assert
            Assert.IsNotNull(result);
            Assert.AreEqual("1-1", result.Uitslag);
            Assert.IsNotNull(result.Spelers);
            IList <Speler> testSpelerList = result.Spelers as IList <Speler>;

            Assert.IsNotNull(testSpelerList[0].Gebruiker);
            Assert.AreEqual("pimm32", testSpelerList[0].Gebruiker.Gebruikersnaam);
            Assert.AreEqual(testSpelerList[0].GebruikerId, testSpelerList[0].Gebruiker.Id);
        }
Example #22
0
        public async Task DeletePartij(Partij partij)
        {
            _partijRepository.Remove(partij);

            await _partijRepository.CommitAsync();
        }
Example #23
0
 public ChangePartyName(Partij p)
 {
     InitializeComponent();
     partij = p;
 }
 public bool Delete(Partij p)
 {
     return(context.Delete(p));
 }
 public bool Update(Partij p)
 {
     return(context.Update(p));
 }