public async Task OpretAsync(AnsøgningDto ansøgning)
        {
            var ansøgningToInsert = _mapper.Map <Ansøgning>(ansøgning);

            ansøgningToInsert.ValidateState();
            await _ansøgningCommand.CreateAsync(ansøgningToInsert);
        }
        public void OpretAsyncTest()
        {
            var moq = new Mock <IAnsøgningCommand>();
            Expression <Action <IAnsøgningCommand> > call = x => x.CreateAsync(It.IsAny <Ansøgning>());

            moq.Setup(call).Verifiable("Method not called");
            var service   = new AnsøgningApplicationService(_mapper, moq.Object);
            var kriterier = new List <IKriterieDto>();

            kriterier.Add(new KvmKriterieDto(50, 60));
            kriterier.Add(new PrisKriterieDto(1000, 5000));
            kriterier.Add(new TilladtDyrKriterieDto(true, false));
            kriterier.Add(new VærelsesKriterieDto(3, 4));
            //multi
            kriterier.Add(new LokationKriterieDto(7100));
            kriterier.Add(new LejemålsTypeKriterieDto(LejemålsType.Hus));

            var ansøgning = new AnsøgningDto()
            {
                Ansøger = new AnsøgerDto(), Aktiv = true, Id = Guid.NewGuid().ToString(), ØvrigKommentar = "Bob", Kriterier = kriterier
            };

            service.OpretAsync(ansøgning).GetAwaiter().GetResult();
            moq.Verify(call);
        }
        public void EditAsyncTest()
        {
            var moq = new Mock <IAnsøgningCommand>();
            Expression <Action <IAnsøgningCommand> > call = x => x.UpdateAsync(It.IsAny <Ansøgning>());

            moq.Setup(call).Verifiable("Method not called");
            var ansøgningToReturn = GenerateMockAnsøgning();

            ansøgningToReturn.SetAnsøger(GenerateMockAnsøger());
            moq.Setup(o => o.GetByIdIncludingAsync(It.IsAny <string>(), o => o.Ansøger)).Returns(Task.FromResult(ansøgningToReturn));
            var service   = new AnsøgningApplicationService(_mapper, moq.Object);
            var kriterier = new List <IKriterieDto>();

            kriterier.Add(new KvmKriterieDto(50, 60));
            kriterier.Add(new LejemålsTypeKriterieDto(LejemålsType.Hus));
            kriterier.Add(new PrisKriterieDto(1000, 5000));
            kriterier.Add(new TilladtDyrKriterieDto(true, false));
            kriterier.Add(new VærelsesKriterieDto(3, 4));
            //multi
            kriterier.Add(new LokationKriterieDto(7100));
            var ansøgning = new AnsøgningDto()
            {
                Ansøger = _mapper.Map <AnsøgerDto>(ansøgningToReturn.Ansøger), Aktiv = true, Id = Guid.NewGuid().ToString(), ØvrigKommentar = "Bob", Kriterier = kriterier
            };

            service.EditAsync(ansøgning).GetAwaiter().GetResult();
            moq.Verify(call, Times.AtLeastOnce);
        }
Esempio n. 4
0
        public async Task <JsonResult> Index()
        {
            List <AnsøgerDto> dtos = new List <AnsøgerDto>();

            foreach (Ansøger a in ((AnsøgerQuery)_ansøgerQuery).GetAll())
            {
                AnsøgerDto dto = _mapper.Map <AnsøgerDto>(a);

                if (dto.Ansøgninger == null)
                {
                    dto.Ansøgninger = new List <AnsøgningDto>();
                }

                List <Ansøgning> ansøgnings = ((AnsøgningQuery)_ansøgningQuery).GetByAnsøgerId(a.Id);
                foreach (Ansøgning aa in ansøgnings)
                {
                    AnsøgningDto aDto = _mapper.Map <AnsøgningDto>(aa);
                    dto.Ansøgninger.Add(aDto);
                }

                dtos.Add(dto);
            }

            return(Json(dtos));
        }
        public static AnsøgningDto MapAnsøgning(Ansøgning a)
        {
            AnsøgningDto dto = new AnsøgningDto();

            //TODO: Map ansøgningsDto når der er Set metoder på

            return(dto);
        }
 private static void AddAnsøgnings(IEnumerable <Ansøgning> ansøgnings, AnsøgerDto dto)
 {
     foreach (Ansøgning a in ansøgnings)
     {
         AnsøgningDto ansøgningDto = MapAnsøgning(a);
         dto.Ansøgninger.Add(ansøgningDto);
     }
 }
        public JsonResult Index()
        {
            List <AnsøgningDto> dtos = new List <AnsøgningDto>();

            foreach (Ansøgning a in _ansøgningQuery.GetAll())
            {
                AnsøgningDto dto = _mapper.Map <AnsøgningDto>(a);
                dtos.Add(dto);
            }
            return(Json(dtos));
        }
        public async Task EditAsync(AnsøgningDto ansøgning)
        {
            //Todo: Venter på karl laver ny metode til at få include(ansøger).theninclude(ansøgers ansøgninger)
            var storedAnsøgning = await _ansøgningCommand.GetByIdIncludingAsync(ansøgning.Id, o => o.Ansøger);

            storedAnsøgning.SetAktiv(ansøgning.Aktiv);
            storedAnsøgning.SetAnsøger(_mapper.Map <Ansøger>(ansøgning.Ansøger));
            storedAnsøgning.SetØvrigKommentar(ansøgning.ØvrigKommentar);
            storedAnsøgning.SetKriterier(_mapper.Map <IEnumerable <Kriterie> >(ansøgning.Kriterier));
            storedAnsøgning.ValidateState();
            storedAnsøgning.Ansøger.ValidateState();
            await _ansøgningCommand.UpdateAsync(storedAnsøgning);
        }
        public async Task <JsonResult> Delete(string id)
        {
            AnsøgningDto dto = _mapper.Map <AnsøgningDto>(_ansøgningQuery.GetById(id));

            if (dto == null)
            {
                return(Json("No ansøgning by that id"));
            }

            await _ansøgningService.SletAsync(id);

            return(Json(dto));
        }
        public JsonResult Get(string id)
        {
            Ansøgning ansøg = _ansøgningQuery.GetById(id);

            if (ansøg == null)
            {
                return(Json("No ansøgning by that id"));
            }

            AnsøgningDto dto = _mapper.Map <AnsøgningDto>(_ansøgningQuery.GetById(id));

            return(Json(dto));
        }
        public async Task <JsonResult> Create()
        {
            var request = HttpContext.Request;

            try
            {
                using (var reader = new StreamReader(request.Body))
                {
                    string body = await reader.ReadToEndAsync();

                    AnsøgningDto dto = System.Text.Json.JsonSerializer.Deserialize <AnsøgningDto>(body);

                    await _ansøgningService.OpretAsync(dto);

                    return(Json(dto));
                }
            }
            catch (Exception ex)
            {
                return(Json(ex.Message));
            }
        }