public Response <IngevoerdAntwoordDTO> FindIngevoerdAntwoord(int id)
 {
     try
     {
         if (id <= 0)
         {
             return(new Response <IngevoerdAntwoordDTO>()
             {
                 Errors = new List <Error>()
                 {
                     new Error {
                         Type = ErrorType.ValidationError, Message = "De id mag niet 0 zijn"
                     }
                 }
             });
         }
         var ingevoerdAntwoord = _repository.GetById(id);
         return(new Response <IngevoerdAntwoordDTO> {
             DTO = IngevoerdAntwoordMapper.MapIngevoerdAntwoordModelToIngevoerdAntwoordDTO(ingevoerdAntwoord)
         });
     }
     catch (Exception ex)
     {
         return(new Response <IngevoerdAntwoordDTO>()
         {
             Errors = new List <Error>()
             {
                 new Error {
                     Type = ErrorType.Exception, Message = ex.Message
                 }
             }
         });
     }
 }
        public IEnumerable <IngevoerdAntwoordDTO> GetAllIngevoerdeAntwoord()
        {
            IEnumerable <IngevoerdAntwoord> ingevoerdeAntwoorden = _repository.GetAll();
            var ingevoerdeAntwoordenDTOs = new List <IngevoerdAntwoordDTO>();

            foreach (IngevoerdAntwoord antwoord in ingevoerdeAntwoorden)
            {
                ingevoerdeAntwoordenDTOs.Add(IngevoerdAntwoordMapper.MapIngevoerdAntwoordModelToIngevoerdAntwoordDTO(antwoord));
            }
            return(ingevoerdeAntwoordenDTOs);
        }
Example #3
0
        public void GetAllIngevoerdeAntwoordenCorrect()
        {
            var ingevoerdeAntwoorden = new List <IngevoerdAntwoord>();

            ingevoerdeAntwoorden.Add(new IngevoerdAntwoord
            {
                GescoordeScore = 5,
                Id             = 1,
                JsonAntwoord   = "JsonAntwoord",
                TeamId         = 1,
                VraagId        = 1
            });

            IQueryable <IngevoerdAntwoord> queryableIngevoerdeAntwoorden = ingevoerdeAntwoorden.AsQueryable();

            var ingevoerdeAntwoordenDTO = new List <IngevoerdAntwoordDTO>();

            foreach (var ingevoerdAntwoord in ingevoerdeAntwoorden)
            {
                ingevoerdeAntwoordenDTO.Add(IngevoerdAntwoordMapper.MapIngevoerdAntwoordModelToIngevoerdAntwoordDTO(ingevoerdAntwoord));
            }

            //Arange
            var ingevoerdeAntwoordRepo = new Mock <ISQLRepository <IngevoerdAntwoord> >();

            ingevoerdeAntwoordRepo.Setup(x => x.GetAll()).Returns(queryableIngevoerdeAntwoorden);

            var ingevoerdAntwoordService = new IngevoerdAntwoordService(ingevoerdeAntwoordRepo.Object);

            //Act
            var allIngevoerdeAntwoorden = ingevoerdAntwoordService.GetAllIngevoerdeAntwoord();

            //Assert
            Assert.That(allIngevoerdeAntwoorden.Count(), Is.EqualTo(ingevoerdeAntwoordenDTO.Count()));

            for (int i = 0; i < allIngevoerdeAntwoorden.Count(); i++)
            {
                Assert.That(allIngevoerdeAntwoorden.ToArray()[i].Id, Is.EqualTo(ingevoerdeAntwoordenDTO.ToArray()[i].Id));
                Assert.That(allIngevoerdeAntwoorden.ToArray()[i].GescoordeScore, Is.EqualTo(ingevoerdeAntwoordenDTO.ToArray()[i].GescoordeScore));
                Assert.That(allIngevoerdeAntwoorden.ToArray()[i].JsonAntwoord, Is.EqualTo(ingevoerdeAntwoordenDTO.ToArray()[i].JsonAntwoord));
                Assert.That(allIngevoerdeAntwoorden.ToArray()[i].TeamId, Is.EqualTo(ingevoerdeAntwoordenDTO.ToArray()[i].TeamId));
                Assert.That(allIngevoerdeAntwoorden.ToArray()[i].VraagId, Is.EqualTo(ingevoerdeAntwoordenDTO.ToArray()[i].VraagId));
            }
        }
        public Response <IngevoerdAntwoordDTO> AddIngevoerdAntwoord(IngevoerdAntwoordDTO ingevoerdAntwoordDTO)
        {
            try
            {
                IngevoerdAntwoordValidator validator = new IngevoerdAntwoordValidator();

                ValidationResult results = validator.Validate(ingevoerdAntwoordDTO);

                if (results.IsValid)
                {
                    var ingevoerdAntwoord       = IngevoerdAntwoordMapper.MapIngevoerdAntwoordDTOToIngevoerdAntwoordModel(ingevoerdAntwoordDTO);
                    var ingevoerdAntwoordEntity = _repository.Add(ingevoerdAntwoord);
                    _repository.SaveChanges();
                    var returnDTO = IngevoerdAntwoordMapper.MapIngevoerdAntwoordModelToIngevoerdAntwoordDTO(ingevoerdAntwoordEntity);
                    var response  = new Response <IngevoerdAntwoordDTO>()
                    {
                        DTO = returnDTO
                    };
                    return(response);
                }
                else
                {
                    return(new Response <IngevoerdAntwoordDTO>()
                    {
                        Errors = results.Errors.Select(x => new Error()
                        {
                            Type = ErrorType.ValidationError, Message = x.ErrorMessage
                        }).ToList()
                    });
                }
            }
            catch (Exception ex) {
                return(new Response <IngevoerdAntwoordDTO>()
                {
                    Errors = new List <Error>()
                    {
                        new Error {
                            Type = ErrorType.Exception, Message = ex.Message
                        }
                    }
                });
            }
        }