private void OpenSelections()
{
string filename = "PluginTester.start";
if (!File.Exists(filename))
{
return;
}
using (StreamReader sr = new StreamReader(filename))
{
string selPatiId = sr.ReadLine();
string selCourseID = sr.ReadLine();
int numPlans = Convert.ToInt32(sr.ReadLine());
_viewModel.SelectedPatient = _viewModel.Patients.FirstOrDefault(s => s.PatientId == selPatiId);
if (_viewModel.SelectedPatient == null)
{
return;
}
MyCourse selCourse = _viewModel.SelectedPatient.Courses.FirstOrDefault(s => s.CourseId == selCourseID);
if (selCourse == null)
{
return;
}
selCourse.IsSelected = true;
_viewModel.SelectedCourse = selCourse;
for (int i = 0; i < numPlans; i++)
{
string planId = sr.ReadLine();
MyPlanItem pItem = _viewModel.SelectedCourse.PlanItems.FirstOrDefault(s => s.pItemId == planId);
if (pItem != null)
{
pItem.IsInScope = true;
_viewModel.PlansInScope.Add(pItem);
}
}
string openPlanId = sr.ReadLine();
foreach (var plan in _viewModel.PlansInScope)
{
if (plan.pItemId == openPlanId)
{
plan.IsOpened = true;
break;
}
}
}
_firstTime = true;
btnStart.IsEnabled = true;
}
public async Task <MyPlanItem> UpdatePlanAsync(MyPlanItem planItem)
{
var myPlanEntity = Mapper.Map <MyPlanEntity>(planItem);
myPlanEntity = await _myPlanRepository.UpdateAsync(myPlanEntity);
planItem = Mapper.Map <MyPlanItem>(myPlanEntity);
return(planItem);
}
public async Task <MyPlanItem> SaveOrUpdatePlanAsync(MyPlanItem planItem)
{
planItem.TemplateWorkDetail = null;
//planItem.Assistant = null;
if (planItem.WorkPlanItemId != 0)
{
return(await UpdatePlanAsync(planItem));
}
else
{
return(await AddMyPlanAsync(planItem));
}
}
public async Task <List <MyPlanItem> > GetUpkeepTemplateDetailByIdForPlan(MyPlanFilters requestHelper)
{
requestHelper.StartDate = requestHelper.StartDate.Date;
requestHelper.EndDate = requestHelper.EndDate.Date.AddDays(1).AddMilliseconds(-1);
// If user is an assistant, he gets all the work items from all users
if (requestHelper.UserType == UserTypeEnum.Assistant)
{
requestHelper.UserId = 0;
}
var virtualItems = new List <MyPlanItem>();
var myPlanWorkItems = await _upkeepTemplateRepository.GetAll()
.Where(t => t.AuthorId == requestHelper.UserId || requestHelper.UserId == 0)
.SelectMany(x => x.UpkeepTemplateDetails)
.Select(x => new MyPlanItem
{
Category = x.Template.Machine.Category,
Machine = x.Template.Machine.Name,
ProfileName = x.Template.ProfileName,
Description = x.Template.Description,
IsRecurring = x.IsRecurring,
ScheduleDate = x.StartDate,
Status = WorkStatusEnum.Pending,
UpkeepTemplateDetailId = x.UpkeepTemplateDetailId,
UpkeepTemplateId = x.Template.UpkeepProfileTemplateId,
WorkDescription = x.Description,
Interval = x.Interval,
Period = x.Period,
OwnerName = x.Template.Author.FullName,
TemplateWorkDetail = Mapper.Map <UpkeepTemplateDetail>(x)
})
.ToListAsync();
// Generate virtual items based on recurrence
foreach (var workItem in myPlanWorkItems)
{
if (workItem.IsRecurring && workItem.Interval != 0 && workItem.Period != 0)
{
for (var i = 1; i < workItem.Period; i++)
{
var virtualWorkItem = new MyPlanItem
{
Category = workItem.Category,
Machine = workItem.Machine,
ProfileName = workItem.ProfileName,
Description = workItem.Description,
IsRecurring = workItem.IsRecurring,
ScheduleDate = workItem.ScheduleDate.AddDays(i * workItem.Interval),
Status = WorkStatusEnum.Pending,
UpkeepTemplateDetailId = workItem.UpkeepTemplateDetailId,
UpkeepTemplateId = workItem.UpkeepTemplateId,
WorkDescription = workItem.WorkDescription,
Interval = workItem.Interval,
Period = workItem.Period,
OwnerName = workItem.OwnerName,
TemplateWorkDetail = workItem.TemplateWorkDetail
};
virtualItems.Add(virtualWorkItem);
}
}
}
myPlanWorkItems.AddRange(virtualItems);
// Replace the work items with non-virtual work items
var relatedtemplateDetails = myPlanWorkItems.Select(x => x.UpkeepTemplateDetailId).Distinct().ToList();
var existingWorkItems = _myPlanRepository.GetAll()
.Include(x => x.Assistant)
.Where(x => relatedtemplateDetails.Contains(x.UpkeepTemplateDetailId))
.Select(x => new MyPlanItem
{
WorkPlanItemId = x.WorkPlanItemId,
UpkeepTemplateDetailId = x.UpkeepTemplateDetailId,
WorkedByUserId = x.WorkedByUserId,
Category = x.TemplateWorkDetail.Template.Machine.Category,
Machine = x.TemplateWorkDetail.Template.Machine.Name,
ProfileName = x.TemplateWorkDetail.Template.ProfileName,
Description = x.TemplateWorkDetail.Template.Description,
IsRecurring = x.TemplateWorkDetail.IsRecurring,
ScheduleDate = x.ScheduleDate,
Status = x.Status,
OwnerName = x.TemplateWorkDetail.Template.Author.FullName,
WorkDescription = x.TemplateWorkDetail.Description,
Interval = x.TemplateWorkDetail.Interval,
Period = x.TemplateWorkDetail.Period,
TemplateWorkDetail = Mapper.Map <UpkeepTemplateDetail>(x.TemplateWorkDetail),
Assistant = Mapper.Map <User>(x.Assistant),
StartWorkDateTime = x.StartWorkDateTime,
CompleteWorkDateTime = x.CompleteWorkDateTime,
NeedActionDateTime = x.NeedActionDateTime
})
.ToList();
if (existingWorkItems.Any())
{
var existingWorkItemsKeys = existingWorkItems.Select(x => new { x.UpkeepTemplateDetailId, x.ScheduleDate }).ToList();
myPlanWorkItems.RemoveAll(x => existingWorkItemsKeys.Contains(new { x.UpkeepTemplateDetailId, x.ScheduleDate }));
myPlanWorkItems.AddRange(existingWorkItems);
}
// Filters
myPlanWorkItems = myPlanWorkItems.Where(x => x.ScheduleDate.Date >= requestHelper.StartDate && x.ScheduleDate.Date <= requestHelper.EndDate).OrderBy(x => x.ScheduleDate).ToList();
if (requestHelper.UpkeepTemplateDetailIds != null && requestHelper.UpkeepTemplateDetailIds.Any())
{
myPlanWorkItems = myPlanWorkItems.Where(x => requestHelper.UpkeepTemplateDetailIds.Contains(x.UpkeepTemplateDetailId)).ToList();
}
return(myPlanWorkItems);
}
