public async Task SaveAppointment_ReturnsAppointment()
{
//Arrrange
var mockRepo = new Mock <IAppointmentRepository>();
mockRepo.Setup(repo => repo.SaveAsync()).ReturnsAsync(true);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AutoMapperProfile());
});
var mapper = mockMapper.CreateMapper();
var service = new AppoinmentService(mockRepo.Object, mapper);
//Act
AppointmentDTO dto = new AppointmentDTO
{
AppointmentTypeId = 1,
Date = DateTime.Now,
IsCancelled = false,
Notes = "",
PatientId = 1,
};
var result = await service.Add(dto);
//Assert
Assert.NotNull(result);
Assert.IsType <AppointmentDTO>(result);
}
/// <summary>
/// Generate a <see cref="Appointment"/> entity.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task <Appointment> GenerateEntity(AppointmentDTO model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var consultant = await GetConsultantEntityAsync(model);
var week = await GetWeekEntityAsync(model);
var day = await GetDayEntityAsync(model);
var timeslot = await GetTimeSlotEntityAsync(model);
var entity = new Appointment
{
Consultant = consultant,
Date = model.Date,
Week = week,
Day = day,
TimeSlot = timeslot
};
return(entity);
}
/// <summary>
/// Generate a <see cref="AppointmentMessage"/>.
/// </summary>
/// <param name="model"></param>
/// <param name="entity"></param>
/// <returns></returns>
private static AppointmentMessage GenerateMessage(AppointmentDTO model, Appointment entity)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var message = new AppointmentMessage
{
AppointmentId = entity.Id,
ConsultantId = entity.ConsultantId,
TimeSlotId = entity.TimeSlotId,
Date = entity.Date,
FirstName = model.Patient.FirstName,
LastName = model.Patient.LastName,
DateOfBirth = model.Patient.DateOfBirth
};
return(message);
}
public int Update(AppointmentDTO dto)
{
var entity = ModelMapper.Mapper.Map <Appointment>(dto);
entity.EntityState = EntityState.Modified;
return(_appointmentRepository.Save(entity));
}
public List <AppointmentDTO> GetAllAvailableAppointments(AppointmentDTO appointmentPreferrences)
{
this.appointmentPreferrences = appointmentPreferrences;
List <AppointmentDTO> appointments = new List <AppointmentDTO>();
List <TimeInterval> allTimeIntervals = GetAllTimeIntervals();
List <Physitian> allPhysitians = GetAllPhysitians();
List <Room> allRooms = GetAllRooms();
PhysitianAvailabilityService physitianAvailabilityService = new PhysitianAvailabilityService();
RoomAvailabilityService roomAvailabilityService = new RoomAvailabilityService();
foreach (TimeInterval timeInterval in allTimeIntervals)
{
foreach (Physitian physitian in allPhysitians)
{
if (physitianAvailabilityService.IsPhysitianAvailable(physitian, timeInterval))
{
foreach (Room room in allRooms)
{
if (roomAvailabilityService.IsRoomAvailable(room, timeInterval))
{
AppointmentDTO appointmentDTO = createAppointment(physitian, room, timeInterval);
appointments.Add(appointmentDTO);
}
}
}
}
}
return(appointments);
}
private async Task HandleMessage(string message)
{
_logger.LogInformation($"Handling Message: {message}");
using var doc = JsonDocument.Parse(message);
var root = doc.RootElement;
var eventType = root.GetProperty("EventType");
//var entity = root.GetProperty("Entity");
using var scope = _serviceScopeFactory.CreateScope();
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
if (eventType.GetString() == "CreateConfirmationEmailMessage")
{
// TODO: deserialize with System.Text.Json
var command = new AppointmentDTO()
{
AppointmentId = root.GetProperty("AppointmentId").GetGuid(),
AppointmentType = root.GetProperty("AppointmentType").GetString(),
ClientEmailAddress = root.GetProperty("ClientEmailAddress").GetString(),
ClientName = root.GetProperty("ClientName").GetString(),
DoctorName = root.GetProperty("DoctorName").GetString(),
PatientName = root.GetProperty("PatientName").GetString(),
AppointmentStartDateTime = root.GetProperty("AppointmentStartDateTime").GetDateTime()
};
await mediator.Send(command);
}
}
private void CloseWorksheet()
{
if (MessageBox.Show("A lezárt munkalapot nem fogja tudni tovább szerkeszteni. Biztosan folytatni szeretné?", "Megerősítés",
MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
{
WorksheetDTO existingWorksheet = _model.Worksheets.FirstOrDefault(w => w.Appointment.Id == WorksheetUnderEdit.Appointment.Id);
if (existingWorksheet != null)
{
_model.Worksheets.Remove(existingWorksheet);
}
_model.Worksheets.Add(new WorksheetDTO
{
Appointment = WorksheetUnderEdit.Appointment,
Items = WorksheetUnderEdit.Items.ToList(),
FinalPrice = WorksheetUnderEdit.FinalPrice,
Closed = true
});
AppointmentDTO appointmentToUpdate = _model.AppointmentList.First(a => a.Id == WorksheetUnderEdit.Appointment.Id);
appointmentToUpdate.HasWorksheet = true;
appointmentToUpdate.HasClosedWorksheet = true;
Appointments = new ObservableCollection <AppointmentDTO>(_model.AppointmentList);
OnEditingFinished();
}
else
{
// do nothing
}
}
private User GetUser(AppointmentDTO dto)
{
var userRepository = _repositoryFactory.GetUserRepository();
var user = new User()
{
Notify = dto.User.Notify,
Email = dto.User.Email,
PhoneNumber = dto.User.PhoneNumber,
FirstName = dto.User.FirstName,
SecondName = dto.User.SecondName
};
var foundUser = userRepository.Find(user);
if (foundUser == null)
{
userRepository.AddIfNotExist(user);
user = userRepository.Find(user);
return(user);
}
return(foundUser);
}
public Appointment Convert(AppointmentDTO dto)
{
var car = GetCar(dto);
var user = GetUser(dto);
var serviceType = GetServiceType(dto);
var appointment = new Appointment()
{
StartTime = dto.StartTime,
Message = dto.Message,
User = user,
UserId = user.Id,
};
if (dto.EndTime != null)
{
appointment.EndTime = dto.EndTime;
}
if (car != null)
{
appointment.Car = car;
appointment.CarId = car.Id;
}
if (serviceType != null)
{
appointment.ServiceTypeId = serviceType.Id;
appointment.ServiceType = serviceType;
}
return(appointment);
}
public void CreateAppointment()
{
var repo = new Mock <IRepository <Appointment> >();
// Arrange
AppointmentRepository rep = new AppointmentRepository();
PeopleRepository peopleRep = new PeopleRepository();
AppointmentsController controller = new AppointmentsController(rep.Repo, peopleRep.Repo);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
var testAppointment = new AppointmentDTO()
{
Client = new PersonDTO(peopleRep.Repo.All().FirstOrDefault(o => o.ApplicationUser.UserName == "*****@*****.**")),
Collaborater = new PersonDTO(peopleRep.Repo.All().FirstOrDefault(o => o.ApplicationUser.UserName == "*****@*****.**")),
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow.AddHours(2),
Status = AppointmentStatus.Pending,
Note = "plata o plomo"
};
// Act
IHttpActionResult result = controller.Post("*****@*****.**", testAppointment);
var contentResult = result as OkNegotiatedContentResult <AppointmentDTO>;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(testAppointment.StartDate, contentResult.Content.StartDate);
}
public IEnumerable <AppointmentDTO> GetQueue(string ap_dept)
{
using (MyContext ctx = new MyContext())
{
var pp = ctx.Appointments.AsNoTracking().Where(e => e.ap_dept == ap_dept);
List <AppointmentDTO> list = new List <AppointmentDTO>();
foreach (var p in pp)
{
AppointmentDTO pdto = new AppointmentDTO();
pdto.ap_patient = p.ap_patient;
pdto.ap_dept = p.ap_dept;
pdto.date = p.date.ToString();
PatientService pa1 = new PatientService();
var dia1 = pa1.GetByID(p.ap_patient);
foreach (var s1 in dia1)
{
pdto.patient_name = s1.patient_name;
}
list.Add(pdto);
}
list = list.OrderBy(e => e.date).ToList();
return(list);
}
}
public void AddNotification(AppointmentDTO appointment, int organizerId)
{
var notificationItem = Mapper.Map <AppointmentDTO, Notification>(appointment);
notificationItem.OrganizerId = organizerId;
notificationItem.Organizer = _users.FindById(organizerId);
notificationItem.Users = new List <User>();
var convert = Mapper.Map <IEnumerable <UserDTO>, IEnumerable <User> >(appointment.Users);
foreach (var item in convert)
{
if (_users.FindById(item.UserId) != null)
{
notificationItem.Users.Add(_users.FindById(item.UserId));
}
}
using (var transaction = _notifications.BeginTransaction())
{
try
{
_notifications.Create(notificationItem);
_notifications.Save();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
MessageBox.Show(e + " from Notify service!");
}
}
}
public async Task <List <JobFormDTO> > Handle(GetAllJobFormsQuery request, CancellationToken cancellationToken)
{
List <Domain.Model.Soporte.JobForm> jobForms = await _jobFormRepository.GetJobForms();
List <JobFormDTO> jobFormDTOs = new List <JobFormDTO>();
foreach (var item in jobForms)
{
ServiceOrderDTO serviceOrderDTO = new ServiceOrderDTO(item.Appointment.ServiceOrder.ServiceOrderId, item.Appointment.ServiceOrder.CreationDate,
item.Appointment.ServiceOrder.Status);
AppointmentDTO appointmentDTO = new AppointmentDTO(
item.Appointment.AppointmentId,
item.Appointment.Status,
item.Appointment.VisitDate,
serviceOrderDTO
);
jobFormDTOs.Add(
new JobFormDTO(
item.JobFormId,
item.Detail,
item.Date,
appointmentDTO
));
}
return(jobFormDTOs);
}
public AppointmentScheduledEvent(AppointmentDTO appointment)
: this()
{
AppointmentScheduled = appointment;
}