public async Task Given_Consultation_To_Update_returns_200()
        {
            var entity = new UpdateConsultationDto
            {
                Comments  = "commentsUpdate",
                Date      = DateTime.Now,
                PatientId = _patients[0].Id,
                DoctorId  = Guid.Parse(_fakeIdentityUsers[0].Id)
            };
            var result = await FakeController.Put(_fakeEntities[0].Id, entity);

            var objectResult = (OkObjectResult)result;

            Assert.NotNull(_fakeEntities[0].UpdatedAt);
            Assert.Equal(200, objectResult.StatusCode);
        }
        public async Task Update_Consultation_And_test_If_User_Changed()
        {
            var environmentVariable = Environment.GetEnvironmentVariable("consultation");
            var jObject             = JObject.Parse(environmentVariable);
            var dto = jObject.ToObject <Consultation>();

            dto.Comments = "NEW COMMENT";

            var update = new UpdateConsultationDto
            {
                Comments  = "commentscomments",
                DoctorId  = Guid.Parse(dto.Doctor.Id),
                PatientId = dto.Patient.Id,
                Date      = DateTime.Now
            };

            var serialize = JsonConvert.SerializeObject(update);
            var content   = new StringContent(serialize, Encoding.UTF8, "application/json");

            var defaultPage = await _client.PutAsync("/api/consultations/" + dto.Id, content);

            var readAsStringAsync = defaultPage.Content.ReadAsStringAsync();
            var json = readAsStringAsync.Result;
            var u    = JObject.Parse(json);
            var user = u.ToObject <Consultation>();


            var defaultPager = await _client.GetAsync("/api/consultations/" + dto.Id);

            var asStringAsync = defaultPager.Content.ReadAsStringAsync();
            var result        = asStringAsync.Result;
            var parsedJObject = JObject.Parse(result);
            var userDto       = parsedJObject.ToObject <Consultation>();

            Assert.Equal(HttpStatusCode.OK, defaultPager.StatusCode);
            Assert.NotNull(environmentVariable);
            Assert.IsType <Consultation>(userDto);
            Assert.Equal(update.Comments, user.Comments);
            Assert.Equal(HttpStatusCode.OK, defaultPage.StatusCode);
            Assert.NotNull(user);
        }
        public async Task <IActionResult> Put(int id, [FromBody] UpdateConsultationDto updateConsultationDto)
        {
            var consultation = await _consultationRepository.Get(id);

            if (consultation == null)
            {
                return(NotFound());
            }

            var doctor = await _identityRepository.GetUserById(updateConsultationDto.DoctorId.ToString());

            if (doctor == null)
            {
                return(BadRequest("Arts bestaat niet."));
            }

            if (updateConsultationDto.PatientId != null)
            {
                var patient = await _patientRepository.Get(updateConsultationDto.PatientId.Value);

                if (patient == null)
                {
                    return(BadRequest("Patient bestaat niet."));
                }
            }

            var userId      = User.Claims.First(u => u.Type == ClaimTypes.Sid).Value;
            var currentUser = await _identityRepository.GetUserById(userId);

            _mapper.Map(updateConsultationDto, consultation);

            consultation.Id = id;

            var updatedConsultation = await _consultationRepository.Update(consultation, currentUser);

            var updatedConsultationDto = _mapper.Map <Consultation, UpdateConsultationDto>(updatedConsultation);

            return(Ok(updatedConsultationDto));
        }