public async Task <ResultModel <SimulationResultModel> > Run(GridInputModel input, DateTime selectDate)
{
var settings = await _settingStoreService.GetAllAsync();
period = settings.FirstOrDefault(x => x.Key == "OperationPeriodInMinutes").IntValue ?? period;
startTime = settings.FirstOrDefault(x => x.Key == "OperationWorkingHourStart").TimeValue;
var workingStartTime = settings.FirstOrDefault(x => x.Key == SettingKey.OperationWorkingHourStart.ToString()).TimeValue.HourToDateTime();
var workingEndTime = settings.FirstOrDefault(x => x.Key == SettingKey.OperationWorkingHourEnd.ToString()).TimeValue.HourToDateTime();
int minPeriod = Convert.ToInt32((new DateTime(workingStartTime.Year, workingStartTime.Month, workingStartTime.Day) - workingStartTime).TotalMinutes / period);
var simulationCount = settings.SingleOrDefault(x => x.Key == SettingKey.SimulationIterationCount.ToString());
//Yarının planlanmıs operasyonları cekilir
var operationList = await _operationPlanStoreService.GetOperationByIdListAsync(selectDate);
//Yarının operasyonlarını operasyon odasına göre grupla
List <RoomPlanModel> roomPlan = operationList.GroupBy(x => x.OperatingRoomId,
(key, g) =>
new RoomPlanModel()
{
OperatingRoomId = key,
OperatingRoomName = g.FirstOrDefault().OperatingRoomName,
SimulationOperationPlanModels = g.ToList() //Maping from OperationPlan entity
}
).ToList();
//Create Calculation List
List <SimulationResultModel> simulationResultList = new List <SimulationResultModel>();
//Iterate simulation list selected time
for (int l = 0; l < simulationCount.IntValue; l++)
{
//Operasyon odasına göre gruplanmış operasyonların sürelerini random olarak değiştirir
var list = GetList(roomPlan);
for (int t = minPeriod; list.Any(x => x.SimulationOperationPlanModels.Any(y => !y.IsFinished)); t++)
{
SetEnd(list, t);
SetStart(list, t);
}
simulationResultList.AddRange(AddSimulationResultList(list, workingStartTime, workingEndTime));
}
var result = Calculation(simulationResultList);
return(new ResultModel <SimulationResultModel>
{
Result = AutoMapper.Mapper.Map <List <SimulationOutputModel> >(result),
Info = new Info()
});
}
public async Task <ResultModel <AppointmentCalendarOutputModel> > GetFutureAppointmentListAsync(AppointmentDayInputModel model)
{
var inputModel = new GridInputModel
{
CurrentPage = model.CurrentPage,
Descending = model.Descending,
PageSize = model.PageSize,
Search = model.Search,
SortBy = model.SortBy
};
var appointments = await GetAsync(inputModel, x => x.PersonnelId == model.DoctorId && x.AppointmentDate >= DateTime.Now);
return(new ResultModel <AppointmentCalendarOutputModel>
{
Info = appointments.Info,
TotalCount = appointments.TotalCount,
Result = AutoMapper.Mapper.Map <List <AppointmentCalendarOutputModel> >(appointments.Result)
});
}
public async Task <ResultModel <PersonnelCategoryOutputModel> > GetPersonnelCategory(GridInputModel input)
{
return(await _PersonnelCategoryStoreService.GetAsync <PersonnelCategoryOutputModel>(input));
}
public async Task <ResultModel <OperatingRoomOutputModel> > GetOperatingRooms(GridInputModel input)
{
return(await _operatingRoomStoreService.GetAsync <OperatingRoomOutputModel>(input));
}
public async Task <ResultModel <EquipmentTypeOutputModel> > GetEquipmentTypes(GridInputModel input)
{
return(await _equipmentTypeStoreService.GetAsync <EquipmentTypeOutputModel>(input));
}
public async Task <ResultModel <AppointmentCalendarOutputModel> > GetAppointmentCalendar(GridInputModel input)
{
return(await _appointmentCalendarStoreService.GetAsync <AppointmentCalendarOutputModel>(input));
}
public async Task <ResultModel <DoctorCalendarOutputModel> > GetDoctorCalendar(GridInputModel input)
{
return(await _doctorCalendarStoreService.GetAsync <DoctorCalendarOutputModel>(input));
}
public async Task <ResultModel <SettingOutputModel> > GetSettings(GridInputModel input)
{
var t = await _settingStoreService.GetAsync <SettingOutputModel>(input);
return(t);
}
/// <summary>
///This methode returns list of specifed type model list.
/// </summary>
/// <typeparam name="TOutputModel"></typeparam>
/// <returns>TOutputModel</returns>
public virtual async Task <ResultModel <TOutputModel> > GetAsync <TOutputModel>(GridInputModel input, Expression <Func <TEntity, bool> > expression = null)
{
var result = await GetAsync(input, expression);
return(new ResultModel <TOutputModel>
{
Result = Mapper.Map <IEnumerable <TOutputModel> >(result.Result),
TotalCount = result.TotalCount,
Info = result.Info
});
}
/// <summary>
/// This methode returns list of entity model.
/// </summary>
/// <param name="GridInputModel">GridInputModel</param>
/// <returns>ResultModel</returns>
public virtual async Task <ResultModel <TModel> > GetAsync(GridInputModel input, Expression <Func <TEntity, bool> > expression)
{
var query = GetQueryable();
if (expression != null)
{
query = query.Where(expression);
}
var projectQuery = query.ProjectTo <TModel>();
if (!string.IsNullOrEmpty(input.Search))
{
List <string> searchableProperties = QueryFilterService <TModel> .GetSearchableProperties();
if (searchableProperties.Count > 0)
{
var lambda = QueryFilterService <TModel> .GetSearchQuery(searchableProperties, input.Search);
projectQuery = projectQuery.Where(lambda);
}
}
if (!string.IsNullOrEmpty(input.SortBy))
{
if (input.Descending == true)
{
projectQuery = projectQuery.OrderByPropertyDescending(input.SortBy);
}
else
{
projectQuery = projectQuery.OrderByProperty(input.SortBy);
}
}
int totalCount = await projectQuery.CountAsync();
if (input.PageSize > 0)
{
projectQuery = projectQuery.Skip((input.CurrentPage - 1) * input.PageSize).Take(input.PageSize);
}
var result = new List <TModel>();
try
{
result = await projectQuery.ToListAsync();
}
catch (Exception ex)
{
//TODO: EF Core sürümü oluşturduğumuz sorguyu bazı istisnai durumlarda async olarak çalıştırmıyor. Geçici olarak bu şekilde yaptım, yeni sürümlerde ya da sorguyu değiştirerek inceleyeceğim.
if (ex.Message.Contains("IAsyncEnumerable"))
{
result = projectQuery.ToList();
}
}
return(new ResultModel <TModel>
{
Result = result,
TotalCount = totalCount,
Info = new Info()
});
}
public async Task <ResultModel <PatientOutputModel> > GetPatient(GridInputModel input)
{
return(await _patientStoreService.GetAsync <PatientOutputModel>(input));
}
public async Task <ResultModel <BranchOutputModel> > GetBranch(GridInputModel input)
{
return(await _branchStoreService.GetAsync <BranchOutputModel>(input));
}
public async Task <ResultModel <FeedbackOutputModel> > GetFeedbacks(GridInputModel input)
{
return(await _feedbackStoreService.GetAsync <FeedbackOutputModel>(input));
}
public async Task <ResultModel <SimulationResultModel> > Run(GridInputModel input, DateTime selectDate)
{
return(await _simulation.Run(input, selectDate));
}
public async Task <ResultModel <WorkTypeOutputModel> > GetWorkTypes(GridInputModel input)
{
return(await _workTypeStoreService.GetAsync <WorkTypeOutputModel>(input));
}
public async Task <ResultModel <OperationPlanListOutputModel> > GetOperationListByDate(GridInputModel input, DateTime operationDate)
{
var projectQuery = _context.OperationPlans.Where(x => x.IsActive && x.OperationDate > operationDate && x.OperationDate < operationDate.AddDays(1)).OrderByDescending(x => x.OperationDate).ProjectTo <OperationPlanListOutputModel>();
int totalCount = await projectQuery.CountAsync();
if (totalCount == 0)
{
projectQuery = _context.Operations.Where(x => x.IsActive && x.Date >= operationDate && x.Date <= operationDate.AddDays(1)).OrderByDescending(x => x.Date).ProjectTo <OperationPlanListOutputModel>();
totalCount = await projectQuery.CountAsync();
}
if (input.PageSize > 0)
{
projectQuery = projectQuery.Skip((input.CurrentPage - 1) * input.PageSize).Take(input.PageSize);
}
var result = await projectQuery.ToListAsync();
return(new ResultModel <OperationPlanListOutputModel>
{
Result = result,
TotalCount = totalCount,
Info = new Info()
});
}
public async Task <ResultModel <OperationPlanListOutputModel> > GetOperationListByDate(GridInputModel input, DateTime operationDate)
{
return(await _operationPlanHistoryStoreService.GetOperationListByDate(input, operationDate));
}
public async Task <ResultModel <EquipmentOutputModel> > GetEquipments(GridInputModel item)
{
return(await _equipmentStoreService.GetAsync <EquipmentOutputModel>(item));
}
public async Task <ResultModel <PersonnelTitleOutputModel> > GetPersonnelTitle(GridInputModel input)
{
return(await _personnelTitleStoreService.GetAsync <PersonnelTitleOutputModel>(input));
}
