public bool PushSlots(DoctorFacility doctorFacility)
{
var mapping = doctorFacility.DoctorMapping;
var defaultDoctorService = mapping.ForeignDoctorService;
if (mapping == null)
{
return(false);
}
var address = mapping.ForeignAddress;
var schedules = _scheduleRepository.GetByDoctorFacility(doctorFacility).Where(s => s.IsFullfilled == false);
if (schedules.Count() == 0)
{
return(false);
}
var slotRangeList = schedules.Select(s => new SlotRange()
{
Start = s.Date.Add(s.Start).SetTimeZone(timeZone),
End = s.Date.Add(s.End).SetTimeZone(timeZone),
DoctorServices = ConvertToSlotDoctorServiceList(s.ForeignDoctorService ?? defaultDoctorService, s.Duration)
}).ToList();
var putSlotsRequest = new PutSlotsRequest()
{
Slots = slotRangeList
};
return(_client.PutSlots(address.ForeignFacilityId, address.ForeignDoctorId, address.Id, putSlotsRequest));
}
public IEnumerable <DoctorSchedule> GetByDoctorFacility(DoctorFacility doctorFacility)
{
return(_db.DoctorSchedules
.Include(ds => ds.DoctorFacility)
.Include(ds => ds.ForeignDoctorService)
.Where(ds => ds.DoctorId == doctorFacility.DoctorId && ds.FacilityId == doctorFacility.FacilityId));
}
public List <VisitSlot> GetSlots(DateTime date, DoctorFacility doctorFacility)
{
var doctorSchedules = _scheduleRepository.GetByDateAndDoctorFacility(date, doctorFacility.DoctorId, doctorFacility.FacilityId)
.Where(ds => !ds.IsFullfilled);
var slots = new List <VisitSlot>();
foreach (var schedule in doctorSchedules)
{
TimeSpan start = schedule.Start;
TimeSpan end = schedule.End;
DateTime dtStart = schedule.Date.Add(start);
DateTime dtEnd = dtStart;
do
{
dtEnd = dtStart.AddMinutes(schedule.Duration);
slots.Add(new VisitSlot()
{
Start = dtStart,
End = dtEnd,
DoctorSchedule = schedule,
DoctorFacility = schedule.DoctorFacility
});
dtStart = dtStart.AddMinutes(schedule.Duration);
} while (dtEnd.AddMinutes(schedule.Duration).TimeOfDay <= end);
}
return(slots);
}
public DoctorMapping GetByAddressAndDoctorFacility(ForeignAddress address, DoctorFacility doctorFacility)
{
return(_db.DoctorMappings.SingleOrDefault(dm =>
dm.ForeignAddress.Id == address.Id
&&
dm.DoctorId == doctorFacility.DoctorId
&&
dm.FacilityId == doctorFacility.FacilityId
));
}
public void RemoveMapping(ForeignAddress address, DoctorFacility doctorFacility)
{
var mapping = GetByAddressAndDoctorFacility(address, doctorFacility);
if (mapping == null)
{
return;
}
_db.DoctorMappings.Remove(mapping);
}
public VisitSlot GetSlot(DateTime start, DateTime end, DoctorFacility doctorFacility)
{
if (start.Date != end.Date)
{
throw new ArgumentException("Start and end parameter should be at the same date");
}
var slots = GetSlots(start.Date, doctorFacility);
return(slots.SingleOrDefault(s => s.Start == start && s.End == end));
}
private IEnumerable <DoctorSchedule> GetSchedules(DoctorFacility doctorFacility, DateTime maxScheduleDate)
{
var schedules = _scheduleRepository.GetByDoctorFacility(doctorFacility)
.Where(s =>
s.IsFullfilled == false &&
s.Start <s.End &&
s.Date.Add(s.Start)> DateTime.Now &&
s.Date.Add(s.End) < maxScheduleDate
);
return(schedules);
}
public bool DeleteSlots(DoctorSchedule schedule, DoctorFacility doctorFacility)
{
if (doctorFacility.IsMapped)
{
var mapping = doctorFacility.DoctorMapping;
var address = mapping.ForeignAddress;
return(_client.DeleteSlots(address.ForeignFacilityId, address.ForeignDoctorId, address.Id, schedule.Date));
}
else
{
return(true);
}
}
public ActionResult Map(string id, [Bind(Include = "DoctorId, FacilityId")] DoctorFacility doctorFacility, string foreignDoctorServiceId)
{
var address = addressRepo.GetById(id);
var foreignDoctorService = doctorServiceRepo.GetById(foreignDoctorServiceId);
try
{
repo.Map(address, doctorFacility, foreignDoctorService);
repo.Save();
return(Json(new { status = true }));
}
catch (Exception ex)
{
return(Json(new { status = false, message = ex.Message }));
}
}
public DoctorMapping Map(ForeignAddress address, DoctorFacility doctorFacility, ForeignDoctorService foreignDoctorService)
{
var mapping = GetByAddressAndDoctorFacility(address, doctorFacility);
if (mapping == null)
{
return(_db.DoctorMappings.Add(new DoctorMapping()
{
DoctorId = doctorFacility.DoctorId,
FacilityId = doctorFacility.FacilityId,
ForeignAddress = address,
ForeignDoctorService = foreignDoctorService
}));
}
return(mapping);
}
public DoctorSchedule FindDoctorSchedule(DoctorFacility doctorFacility, DateTime start, DateTime end, string foreignDoctorServiceId)
{
var doctorSchedules = _scheduleRepository.GetByDateAndDoctorFacility(start, doctorFacility.DoctorId, doctorFacility.FacilityId);
DoctorSchedule schedule = doctorSchedules.FirstOrDefault(ds =>
ds.Start <= start.TimeOfDay && end.TimeOfDay <= ds.End
&&
ds.ForeignDoctorServiceId == foreignDoctorServiceId
);
if (schedule == null)
{
schedule = doctorSchedules.FirstOrDefault(ds => ds.Start <= start.TimeOfDay && end.TimeOfDay <= ds.End);
}
return(schedule);
}
/// <summary>
/// Delete all slots on Docplanner side
/// </summary>
/// <param name="doctorFacility"></param>
/// <returns></returns>
public bool ClearDPCalendar(DoctorFacility doctorFacility)
{
var mapping = doctorFacility.DoctorMapping;
if (mapping == null)
{
return(false);
}
var address = mapping.ForeignAddress;
var startDate = TimeZone.CurrentTimeZone.ToLocalTime(DateTime.Now);
var maxSlotDate = CultureInfo.InvariantCulture.Calendar.AddWeeks(DateTime.Now, 12);
var schedules = GetSchedules(doctorFacility, maxSlotDate)
.GroupBy(s => s.Date.Date);
var slots = _client.GetSlots(address.ForeignFacilityId, address.ForeignDoctorId, address.Id, startDate, maxSlotDate);
//If there aren't any slots there is nothing to do.
if (slots == null || slots.Any() == false)
{
return(true);
}
//Clear slots for the dates which has slots.
//No need to send request for the days which don't have any slots.
foreach (var item in slots.GroupBy(s => s.Start.Date))
{
//If we have valid schedules for a day, do not clear it, it will be replaced anyway.
if (schedules.Any(s => s.Key == item.Key))
{
continue;
}
_client.DeleteSlots(address.ForeignFacilityId, address.ForeignDoctorId, address.Id, item.Key);
}
return(true);
}
public bool PushSlots(DoctorFacility doctorFacility)
{
var mapping = doctorFacility.DoctorMapping;
if (mapping == null)
{
return(false);
}
var maxSlotDate = CultureInfo.InvariantCulture.Calendar.AddWeeks(DateTime.Now, 12);
var schedules = GetSchedules(doctorFacility, maxSlotDate);
if (schedules.Count() == 0)
{
return(false);
}
var calendarBlocks = CalendarGenerator.MergeSchedules(schedules);
var address = mapping.ForeignAddress;
var groupedSchedules = schedules.GroupBy(s => s.Date.Date);
var defaultDoctorService = mapping.ForeignDoctorService;
var slots = calendarBlocks.Select(b => new SlotRange()
{
Start = b.Start,
End = b.End,
DoctorServices = ConvertToSlotDoctorServiceList(b.DoctorService ?? defaultDoctorService, b.Duration)
});
var putSlotsRequest = new PutSlotsRequest()
{
Slots = slots.ToList()
};
return(_client.PutSlots(address.ForeignFacilityId, address.ForeignDoctorId, address.Id, putSlotsRequest));
}
public bool IsSlotExist(DateTime start, DateTime end, DoctorFacility doctorFacility)
{
return(GetSlot(start, end, doctorFacility) != null);
}
public void Update(DoctorFacility entity)
{
_db.DoctorFacilities.Attach(entity);
_db.Entry(entity).State = EntityState.Modified;
}
public void Insert(DoctorFacility entity)
{
_db.DoctorFacilities.Add(entity);
}
