private static void UpdateExistingDoctorFields(Guid id, DoctorDto doctorDto, PersistenceClassesDataContext dataContext)
{
var doctor = dataContext.Doctors.FirstOrDefault(p => p.Guid.Equals(id));
if (doctor == null)
{
throw GetResponseException(HttpStatusCode.NotFound, Messages.DoctorDoesNotExist);
}
if (doctorDto.Name != null)
{
doctor.Name = doctorDto.Name;
}
if (doctorDto.MiddleName != null)
{
doctor.MiddleName = doctorDto.MiddleName;
}
if (doctorDto.FamilyName != null)
{
doctor.FamilyName = doctorDto.FamilyName;
}
if (doctorDto.Address != null)
{
doctor.Address = doctorDto.Address;
}
if (doctorDto.MobilePhone != null)
{
doctor.MobilePhone = doctorDto.MobilePhone;
}
if (doctorDto.Egn != null)
{
doctor.Egn = doctorDto.Egn;
}
dataContext.SubmitChanges();
}
public int AddDoctor([FromBody] DoctorDto dto)
{
if (dto == null)
{
return(0);
}
Врач doc = new Врач()
{
ВнешнийХэш = dto.Hash,
};
int?userId = dto.UserId;
if (userId == null)
{
userId = new UserController().AddUser(dto.User);
}
doc.Пользователь = db.GetFromDatabase <Пользователь>(x => x.Id == userId).FirstOrDefault();
if (string.IsNullOrEmpty(doc.ВнешнийХэш))
{
doc.ВнешнийХэш = HashHelper.GetHashForNewEntity(doc);
}
db.Insert(doc);
return(doc.Id);
}
public DoctorDto GetDoctor(int id)
{
var doctor = new DoctorDto();
using (SqlConnection connection = new SqlConnection(ConString))
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = "select IdDoctor, FirstName, LastName, Email " +
"from Doctors " +
"where IdDoctor = @id";
command.Parameters.AddWithValue("id", id);
connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
if (!dataReader.Read())
{
return(null);
}
doctor.IdDoctor = int.Parse(dataReader["IdDoctor"].ToString());
doctor.FirstName = dataReader["FirstName"].ToString();
doctor.LastName = dataReader["LastName"].ToString();
doctor.Email = dataReader["Email"].ToString();
dataReader.Close();
}
return(doctor);
}
public async Task <DoctorDto> Post(DoctorDto doctor)
{
using (var db = new PatientContext())
{
using (var transaction = db.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
db.Doctors.AddOrUpdate(doctor.Doctor);
db.DoctorAilmentLookups.AddOrUpdate(doctor.DoctorAilmentLookups.ToArray());
await db.SaveChangesAsync();
transaction.Commit();
return(doctor);
}
catch (Exception ex)
{
transaction.Rollback();
Console.WriteLine(ex);
throw;
}
}
}
}
public async Task EditDoctorAsync()
{
var doctorId = Guid.Parse("00000000-0000-0000-0000-000000000011");
const string name = "John";
const string surname = "Malecki";
const Specialization specialization = Specialization.Anesthesiologist;
var returnedDoctor = new Doctor
{
Id = doctorId,
Name = name,
Surname = surname,
Specialization = specialization
};
var updatedDoctor = new DoctorDto
{
Id = doctorId,
Name = name,
Surname = surname,
Specialization = Specialization.AllergistImmunologist
};
var mockManager = new FacadeMockManager();
var doctorRepositoryMock = mockManager.ConfigureGetAndUpdateRepositoryMock <Doctor>(returnedDoctor, nameof(Doctor.Specialization));
var doctorQueryMock = mockManager.ConfigureQueryObjectMock <DoctorDto, Doctor, DoctorFilterDto>(null);
var doctorFacade = CreateDoctorFacade(doctorQueryMock, doctorRepositoryMock);
await doctorFacade.EditDoctorAsync(updatedDoctor);
Assert.AreEqual((int)updatedDoctor.Specialization, mockManager.CapturedUpdatedUnit);
}
public async Task <ActionResult> Create(DoctorCreateModel doctorCreateModel)
{
if (!ModelState.IsValid)
{
return(View(doctorCreateModel));
}
DoctorDto doctorDto = new DoctorDto
{
Username = doctorCreateModel.Username,
Password = doctorCreateModel.Password,
Specialization = doctorCreateModel.Specialization,
Name = doctorCreateModel.Name,
Surname = doctorCreateModel.Surname
};
if (await PatientFacade.GetPatientByUsernameAsync(doctorCreateModel.Username) != null ||
await DoctorFacade.GetDoctorByUsernameAsync(doctorCreateModel.Username) != null)
{
ModelState.AddModelError("Username", "Account with that username already exists");
return(View(doctorCreateModel));
}
await DoctorFacade.RegisterDoctor(doctorDto);
return(RedirectToAction("Login", "Account"));
}
public async Task <ActionResult> Update(DoctorUpdateModel doctorUpdateModel)
{
if (!ModelState.IsValid)
{
return(View(doctorUpdateModel));
}
doctorUpdateModel.Username = HttpContext.User.Identity.Name;
var doctorToUpdate = await DoctorFacade.GetDoctorByUsernameAsync(doctorUpdateModel.Username);
if (doctorToUpdate == null)
{
ModelState.AddModelError("Username", "Account does not exist");
return(View(doctorUpdateModel));
}
DoctorDto doctorDto = new DoctorDto
{
Username = HttpContext.User.Identity.Name,
Id = doctorToUpdate.Id,
Specialization = doctorToUpdate.Specialization,
Name = doctorUpdateModel.Name,
Surname = doctorUpdateModel.Surname
};
await DoctorFacade.EditDoctorAsync(doctorDto);
return(RedirectToAction("Index", "Home"));
}
public bool RegisterDoctor(DoctorDto doctor)
{
if (_userRepository.Single(x => x.Login == doctor.Login) != null)
{
return(false);
}
var salt = EncryptionUtil.GenerateSalt();
var passwd = EncryptionUtil.HashPassword(doctor.Password, salt);
var user = _mapper.Map <User>(doctor);
user.Password = passwd;
user.Salt = salt;
user.Role = _roleRepository.Single(x => x.Name == doctor.Role.ToString());
var newDoctor = new Doctor
{
Specialization = _specializationRepository.Single(x => x.Name == doctor.SpecializationName),
User = user
};
_userRepository.Add(user);
_doctorRepository.Add(newDoctor);
return(true);
}
public async Task <IActionResult> UpdateDoctor(Guid doctorId, [FromBody] DoctorDto doctor)
{
await _doctorService.UpdateDoctor(doctorId, doctor.Street, doctor.PostCode,
doctor.PhoneNumber, doctor.City);
return(NoContent());
}
public IEnumerable <DoctorDto> GetDoctors()
{
var list = new List <DoctorDto>();
using (SqlConnection connection = new SqlConnection(ConString))
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = "select IdDoctor, FirstName, LastName, Email " +
"from Doctors";
connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
while (dataReader.Read())
{
var doctor = new DoctorDto
{
IdDoctor = int.Parse(dataReader["IdDoctor"].ToString()),
FirstName = dataReader["FirstName"].ToString(),
LastName = dataReader["LastName"].ToString(),
Email = dataReader["Email"].ToString()
};
list.Add(doctor);
}
dataReader.Close();
}
return(list);
}
public async Task <IActionResult> Create(DoctorDto model)
{
var doctor = new Doctor();
if (ModelState.IsValid)
{
string uniqueName = null;
if (model.Photo != null)
{
var folderPath = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
var filePath = Path.Combine(folderPath, uniqueName);
if (filePath != null)
{
model.Photo.CopyTo(new FileStream(filePath, mode: FileMode.Create));
}
}
doctor = _mapper.Map <Doctor>(model);
doctor.ProfilePhoto = uniqueName;
_context.Add(doctor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public void ReceiveVisitRequest(DoctorDto doctor, VisitRequestDto visitRequest)
{
if (_activeDoctors.Any(x => x.Key.Id == doctor.Id))
{
_activeDoctors.First(x => x.Key.Id == doctor.Id).Value.UpdatePendingRequests(visitRequest);
}
}
public async Task <ActionResult <DoctorDto> > Put(int id, DoctorDto model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest("Model is not valid"));
}
var oldDoctor = await _doctorService.GetDoctorByIdAsync(id);
if (oldDoctor == null)
{
return(NotFound($"Could not find camp with id of {id}"));
}
var updatedDoctor = _mapper.Map(model, oldDoctor);
if (await _doctorService.UpdateDoctor(updatedDoctor))
{
return(Ok(updatedDoctor));
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Database Failure: {e}"));
}
return(BadRequest());
}
/// <summary>
/// Updates the specified doctor.
/// </summary>
/// <param name="item">The item.</param>
public void Update(DoctorDto item)
{
var entity = this.Session.Get <Doctor>(item.Id);
Mapper.Map <DoctorDto, Doctor>(item, entity);
this.Session.Merge(entity);
}
public async Task <string> Create(DoctorDto model)
{
//var officer = _httpContextAccessor.HttpContext.User.Identity.Name;
//if (officer == "SuperAdmin")
//{
// officer = "Admin";
//}
var user = new ApplicationUser
{
UserName = model.EmailAddress,
SurName = model.SurName,
Email = model.EmailAddress,
FirstName = model.FirstName,
OtherName = model.OtherName,
MobileNo = model.MobileNo,
Sex = model.Sex,
Address = model.Address,
EntityStatus = model.Status
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, "Doctor");
Doctor doctor = new Doctor();
doctor.UserId = user.Id;
doctor.SurName = model.SurName;
doctor.FirstName = model.SurName;
doctor.OtherName = model.OtherName;
doctor.EmailAddress = model.EmailAddress;
doctor.PhoneNo = model.PhoneNo;
doctor.MobileNo = model.MobileNo;
doctor.Sex = model.Sex;
doctor.Address = model.Address;
doctor.Status = model.Status;
doctor.ProfilePicture = model.ProfilePicture;
doctor.Address = model.Address;
doctor.Biography = model.Biography;
doctor.BloodGroupId = model.BloodGroupId;
doctor.DepartmentId = model.DepartmentId;
doctor.Designation = model.Designation;
doctor.Specialist = model.Specialist;
doctor.Education = model.Education;
_context.Doctor.Add(doctor);
await _context.SaveChangesAsync();
return("true");
}
var errors = result.Errors;
var message = string.Join(",", errors);
return(message);
}
public async Task <IActionResult> Post([FromBody] DoctorDto doctor)
{
await _doctorService.AddDoctor(doctor.Email, doctor.Password, doctor.Pesel,
doctor.FirstName, doctor.SecondName, doctor.PhoneNumber, doctor.PostCode,
doctor.City, doctor.Street, doctor.HouseNumber);
return(Created("/doctors/5", null));
}
private static Doctor CreateDoctor(DoctorDto doctorDto, SysUser sysUser)
{
var doctor = Mapper.Map <DoctorDto, Doctor>(doctorDto);
doctor.Guid = Guid.Empty;
doctor.UserId = sysUser.Guid;
return(doctor);
}
private void CreateClick()
{
if (Doctors.Count == 0 || Doctors[Doctors.Count - 1].DoctorId != 0)
{
ToSave = new DoctorDto();
Doctors.Add(ToSave);
}
}
public IEnumerable <VisitRequestDto> GetPendingRequests(DoctorDto doctor)
{
var pendingRequests = _requestsRepository.Get(d => d.DoctorId == doctor.Id && d.IsApproved == null,
cfg => cfg.Doctor, cfg => cfg.Doctor.User, cfg => cfg.Patient, cfg => cfg.Patient.User,
cfg => cfg.Doctor.Specialization);
return(_mapper.Map <VisitRequestDto[]>(pendingRequests));
}
private bool CompareInput(DoctorDto doctorDto, string name)
{
if (doctorDto.Name.ToLower().Contains(name.ToLower()) || doctorDto.Surname.ToLower().Contains(name.ToLower()))
{
return(true);
}
return(false);
}
private DoctorDto HideSensitiveInformationIfNeeded(DoctorDto doctorDto)
{
if (IsUserInRole(User, UserRole.Patient))
{
doctorDto.Egn = "HIDDEN";
}
return(doctorDto);
}
private void CancelClick()
{
if (ToSave.DoctorId == 0)
{
Doctors.RemoveAt(Doctors.Count - 1);
}
ToSave = new DoctorDto();
}
public void Doctor_dto_to_doctor()
{
DoctorDto doctorDto = CreateDoctorDto();
Doctor myDoctor = HospitalApp.Adapters.DoctorAdapter.DoctorDtoToDoctor(doctorDto);
myDoctor.ShouldBeOfType(typeof(Doctor));
}
public void UpdateExistingDoctor(Guid id, [FromBody] DoctorDto doctorDto)
{
EnsureNotInRole(User, UserRole.Patient, Messages.PatientNotAllowedToExecute);
if (IsUserInRole(User, UserRole.Doctor))
{
EnsureId(User, id, Messages.DoctorNotAllowedToModifyOtherDoctors);
}
Execute(dataContext => UpdateExistingDoctorFields(id, doctorDto, dataContext));
}
public void LogoutDoctor(DoctorDto doctor)
{
var foundDoctor = _activeDoctors.FirstOrDefault(x => x.Key.Id == doctor.Id);
if (foundDoctor.Key != null)
{
_activeDoctors.Remove(foundDoctor.Key);
}
}
public static Doctor DoctorDtoToDoctor(DoctorDto dto)
{
Doctor doctor = new Doctor();
doctor.Id = dto.Id;
doctor.Name = dto.Name;
doctor.Surname = dto.Surname;
return(doctor);
}
public static DoctorDto DoctorToDoctorDto(Doctor doctor)
{
DoctorDto dto = new DoctorDto();
dto.Id = doctor.Id;
dto.Name = doctor.Name;
dto.Surname = doctor.Surname;
return(dto);
}
/// <summary>
/// Removes the specified doctor.
/// </summary>
/// <param name="item">The item.</param>
public void Remove(DoctorDto item)
{
Assert.IsNotNull(item, "item");
if (!this.CanRemove(item))
{
throw new ReferencialIntegrityException();
}
this.Remove <Doctor>(item);
}
public IActionResult Add(DoctorDto doctorDto)
{
if (_doctorService.Add(doctorDto) == null)
{
return(NotFound());
}
return(Ok(doctorDto));
}
public async Task <ActionResult> UpdateInfoAsync(DoctorDto doctor)
{
var model = _mapper.Map <DoctorDto, DoctorModel>(doctor);
model.Id = UserId;
var result = await _doctorService.UpdateAsync(model);
return(StatusCode((int)result));
}
