public void Test_Schedule_PreStep_And_SchedulingOffset()
{
var procedure = new Procedure(new ProcedureType(), "111", "1.111");
var protocolStep = new ProtocolAssignmentStep(new Protocol(procedure));
procedure.AddProcedureStep(protocolStep);
var registrationStep = new RegistrationProcedureStep(procedure);
var modalityStep = new ModalityProcedureStep(procedure, "description", new Modality());
var documentationStep = new DocumentationProcedureStep(procedure);
var reportingStep = new ConcreteReportingProcedureStep(procedure);
Assert.IsNull(protocolStep.Scheduling.StartTime);
Assert.IsNull(registrationStep.Scheduling.StartTime);
Assert.IsNull(modalityStep.Scheduling.StartTime);
Assert.IsNull(documentationStep.Scheduling.StartTime);
Assert.IsNull(reportingStep.Scheduling.StartTime);
var now = DateTime.Now;
procedure.Schedule(now);
Assert.AreEqual(now.Truncate(DateTimePrecision.Minute), procedure.ScheduledStartTime);
Assert.AreEqual(protocolStep.CreationTime, protocolStep.Scheduling.StartTime);
Assert.AreEqual(procedure.ScheduledStartTime, registrationStep.Scheduling.StartTime);
Assert.AreEqual(procedure.ScheduledStartTime, modalityStep.Scheduling.StartTime);
Assert.IsNull(documentationStep.Scheduling.StartTime);
Assert.IsNull(reportingStep.Scheduling.StartTime);
}
public void Test_IsPerformed()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());
Assert.IsFalse(procedure.IsPerformed);
ps1.Start(new Staff());
Assert.IsFalse(procedure.IsPerformed);
ps1.Complete(Platform.Time);
Assert.IsFalse(procedure.IsPerformed);
ps2.Start(new Staff());
ps3.Start(new Staff());
Assert.IsFalse(procedure.IsPerformed);
ps2.Discontinue();
Assert.IsFalse(procedure.IsPerformed);
ps3.Complete();
Assert.IsTrue(procedure.IsPerformed);
}
public void Test_CompleteProcedureStepFromInProgress()
{
Order order = TestOrderFactory.CreateOrder(1, 1, true);
Procedure rp1 = CollectionUtils.FirstElement(order.Procedures);
ModalityProcedureStep mps1 = rp1.ModalityProcedureSteps[0];
CheckStatus(ActivityStatus.SC, mps1);
mps1.Start(TestStaffFactory.CreateStaff(new StaffTypeEnum("STEC", null, null)));
CheckStatus(ActivityStatus.IP, mps1);
mps1.Complete();
CheckStatus(ActivityStatus.CM, mps1);
Assert.IsNotNull(mps1.StartTime);
Assert.IsNotNull(mps1.EndTime);
CheckStatus(ProcedureStatus.IP, rp1);
Assert.IsNotNull(rp1.StartTime);
Assert.IsNull(rp1.EndTime);
CheckStatus(OrderStatus.IP, order);
Assert.IsNotNull(order.StartTime);
Assert.IsNull(order.EndTime);
}
public void Test_PerformedTime()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
ps1.Start(new Staff());
ps1.Complete(Platform.Time);
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
ps2.Start(new Staff());
ps2.Complete(Platform.Time + TimeSpan.FromDays(1));
var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());
ps3.Start(new Staff());
ps3.Complete(Platform.Time + TimeSpan.FromDays(2));
var ps4 = new ModalityProcedureStep(procedure, "ps4", new Modality());
ps4.Start(new Staff());
ps4.Complete(Platform.Time + TimeSpan.FromDays(3));
Assert.AreEqual(ps4.EndTime, procedure.PerformedTime);
}
public void Test_IsTerminatedTrue()
{
var procedure = new Procedure();
procedure.Cancel();
Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
procedure.Complete(Platform.Time);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
procedure = new Procedure();
procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
}
public void Test_PerformedTime_NoneCompleted()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
Assert.IsNull(procedure.PerformedTime);
}
public void Test_ModailtyProcedureSteps()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "description", new Modality());
var ps2 = new DocumentationProcedureStep(procedure);
Assert.AreEqual(2, procedure.ProcedureSteps.Count);
Assert.IsTrue(procedure.ModalityProcedureSteps.Contains(ps1));
Assert.AreEqual(1, procedure.ModalityProcedureSteps.Count);
}
public void Test_Name()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.AreEqual("Modality", procedureStep.Name);
}
public void Test_IsPreStep()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.IsFalse(procedureStep.IsPreStep);
}
public void Test_Name()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.AreEqual("Modality", procedureStep.Name);
}
public void Test_IsPreStep()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.IsFalse(procedureStep.IsPreStep);
}
public void Test_Schedule_InProgress()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
procedure.Schedule(Platform.Time);
}
public void Test_Cancel_InProgress()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
procedure.Cancel();
}
public void Test_GetLinkedProcedures()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.IsNotNull(procedureStep.GetLinkedProcedures());
Assert.IsEmpty(procedureStep.GetLinkedProcedures());
}
public void Test_GetLinkedProcedures()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.IsNotNull(procedureStep.GetLinkedProcedures());
Assert.IsEmpty(procedureStep.GetLinkedProcedures());
}
public void Test_Cancel_Completed()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Complete(DateTime.Now);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
procedure.Cancel();
}
public void Test_Cancel_Discontinued()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
procedure.Cancel();
}
public void Test_IsPerformed_NonePerformed()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
ps1.Start(new Staff());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
Assert.IsFalse(procedure.IsPerformed);
}
public void Test_AddProcedureStep_StepNotScheduling()
{
var procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
procedure.AddProcedureStep(procedureStep);
}
public void Test_Schedule_Complete()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Complete(DateTime.Now);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
procedure.Schedule(Platform.Time);
}
private static void AddProcedureSteps(Procedure procedure, int numMps)
{
Modality m = new Modality("01", "CT", procedure.PerformingFacility, null, null);
for (int s = 0; s < numMps; s++)
{
ModalityProcedureStep step = new ModalityProcedureStep();
step.Description = "MPS 10" + s;
step.Modality = m;
procedure.AddProcedureStep(step);
}
}
public void Test_Constructor()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.AreEqual(procedure, procedureStep.Procedure);
Assert.AreEqual(description, procedureStep.Description);
Assert.AreEqual(modality, procedureStep.Modality);
}
public void Test_IsTerminatedFalse()
{
var procedure = new Procedure();
Assert.IsFalse(procedure.IsTerminated);
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.IsFalse(procedure.IsTerminated);
}
public void Test_Constructor()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
Assert.AreEqual(procedure, procedureStep.Procedure);
Assert.AreEqual(description, procedureStep.Description);
Assert.AreEqual(modality, procedureStep.Modality);
}
private void Refresh()
{
if (_worklistItem != null)
{
_scheduledProcStep = _workflowService.LoadWorklistItemPreview(_worklistItem);
_patientProfile = CollectionUtils.SelectFirst <PatientProfile>(
_scheduledProcStep.RequestedProcedure.Order.Patient.Profiles,
delegate(PatientProfile pp) { return(_worklistItem.PatientProfile.RefersTo(pp)); });
}
NotifyAllPropertiesChanged();
}
public void Test_CanExecute_InProgress()
{
Order order = new Order();
CancelOrderOperation op = new CancelOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
Assert.AreEqual(OrderStatus.IP, order.Status);
Assert.IsFalse(op.CanExecute(order));
}
public void Test_Execute_InProgress()
{
Order order = new Order();
OrderCancelInfo info = new OrderCancelInfo();
CancelOrderOperation op = new CancelOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
Assert.AreEqual(OrderStatus.IP, order.Status);
op.Execute(order, info);
}
public void Test_GetRelatedProcedureSteps()
{
Procedure p1 = new Procedure();
string description = "description.";
Modality modality = new Modality();
// attach 2 procedure steps to p1
ModalityProcedureStep ps11 = new ModalityProcedureStep(p1, description, modality);
ModalityProcedureStep ps12 = new ModalityProcedureStep(p1, description, modality);
// expect that each ps is only related to itself
Assert.IsEmpty(ps11.GetRelatedProcedureSteps());
Assert.IsEmpty(ps12.GetRelatedProcedureSteps());
}
public void Test_Execute()
{
Order order = new Order();
OrderCancelInfo info = new OrderCancelInfo();
DiscontinueOrderOperation op = new DiscontinueOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
Assert.AreEqual(OrderStatus.IP, order.Status);
op.Execute(order, info);
}
public void Discontinue()
{
var procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
}
public void Test_Execute_Complete()
{
Order order = new Order();
OrderCancelInfo info = new OrderCancelInfo();
DiscontinueOrderOperation op = new DiscontinueOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
procedure.Complete(DateTime.Now);
order.UpdateStatus();
Assert.AreEqual(OrderStatus.CM, order.Status);
op.Execute(order, info);
}
public void Test_CanExecute_Complete()
{
Order order = new Order();
DiscontinueOrderOperation op = new DiscontinueOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
procedure.Complete(DateTime.Now);
order.UpdateStatus();
Assert.AreEqual(OrderStatus.CM, order.Status);
Assert.IsFalse(op.CanExecute(order));
}
public void Test_Execute_Complete()
{
Order order = new Order();
OrderCancelInfo info = new OrderCancelInfo();
CancelOrderOperation op = new CancelOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
procedure.Complete(DateTime.Now);
order.UpdateStatus();
Assert.AreEqual(OrderStatus.CM, order.Status);
op.Execute(order, info);
}
public void Test_GetProcedureStep()
{
var procedure = new Procedure();
Assert.IsNull(procedure.GetProcedureStep(delegate { return(true); }));
var ps1 = new DocumentationProcedureStep(procedure);
var ps2 = new ModalityProcedureStep(procedure, "new Modality", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "new Modality", new Modality());
var ps4 = new ConcreteReportingProcedureStep(procedure);
Assert.IsNull(procedure.GetProcedureStep(delegate { return(false); }));
Assert.AreEqual(ps1, procedure.GetProcedureStep(ps => ps is DocumentationProcedureStep));
Assert.AreEqual(ps2, procedure.GetProcedureStep(ps => ps is ModalityProcedureStep));
Assert.AreEqual(ps4, procedure.GetProcedureStep(ps => ps is ReportingProcedureStep));
Assert.IsNull(procedure.GetProcedureStep(ps => ps is ProtocolProcedureStep));
}
public void Test_Complete()
{
Procedure procedure = new Procedure();
Report report = new Report(procedure);
ReportPart reportPart = new ReportPart(report, 0);
// This modality procedure step is created such that when the procedure tries to update its status
// the detection of no ModalityProcedureSteps makes any procedure trying to update its status set itself
// to discontinued, which for this test, is undesirable, this situation will probably never happen
// in practice.
ModalityProcedureStep modalityStep = new ModalityProcedureStep(procedure, "New modality.", new Modality());
InterpretationStep previousStep = new InterpretationStep(procedure);
previousStep.ReportPart = reportPart;
PublicationStep procedureStep = new PublicationStep(previousStep);
procedureStep.Start(new Staff());
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
Assert.AreEqual(0, procedureStep.ReportPart.Index);
Assert.AreEqual(ReportPartStatus.D, procedureStep.ReportPart.Status);
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return(p.Status == ProcedureStatus.IP);
}));
procedureStep.Complete();
Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
Assert.AreEqual(ReportPartStatus.F, procedureStep.ReportPart.Status);
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return(p.Status == ProcedureStatus.CM);
}));
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return(p.EndTime == procedureStep.EndTime);
}));
}
public void Test_GetProcedureSteps()
{
var procedure = new Procedure();
Assert.IsEmpty(procedure.GetProcedureSteps(delegate { return(true); }));
var ps1 = new DocumentationProcedureStep(procedure);
var ps2 = new ModalityProcedureStep(procedure, "1", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "2", new Modality());
var ps4 = new ProtocolAssignmentStep();
procedure.AddProcedureStep(ps4);
Assert.AreEqual(4, procedure.GetProcedureSteps(delegate { return(true); }).Count);
Assert.IsEmpty(procedure.GetProcedureSteps(delegate { return(false); }));
Assert.AreEqual(1, procedure.GetProcedureSteps(ps => ps is DocumentationProcedureStep).Count);
Assert.AreEqual(2, procedure.GetProcedureSteps(ps => ps is ModalityProcedureStep).Count);
Assert.AreEqual(0, procedure.GetProcedureSteps(ps => ps is ReportingProcedureStep).Count);
Assert.AreEqual(1, procedure.GetProcedureSteps(ps => ps is ProtocolProcedureStep).Count);
}
public void Test_Reassign()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
procedureStep.Suspend();
Staff performer = new Staff();
ProcedureStep newStep = procedureStep.Reassign(performer); // Perform event
// just need to test that it returns a new instance of this class
// everything else has been covered in base class tests
Assert.IsNotNull(newStep);
Assert.AreNotEqual(this, newStep);
Assert.IsInstanceOfType(typeof(ModalityProcedureStep), newStep);
Assert.AreEqual(procedure, newStep.Procedure);
Assert.AreEqual(description, ((ModalityProcedureStep)newStep).Description);
Assert.AreEqual(modality, ((ModalityProcedureStep)newStep).Modality);
}
public void Test_IsPerformed()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());
Assert.IsFalse(procedure.IsPerformed);
ps1.Start(new Staff());
Assert.IsFalse(procedure.IsPerformed);
ps1.Complete(Platform.Time);
Assert.IsFalse(procedure.IsPerformed);
ps2.Start(new Staff());
ps3.Start(new Staff());
Assert.IsFalse(procedure.IsPerformed);
ps2.Discontinue();
Assert.IsFalse(procedure.IsPerformed);
ps3.Complete();
Assert.IsTrue(procedure.IsPerformed);
}
public void Test_GetRelatedProcedureSteps()
{
Procedure p1 = new Procedure();
string description = "description.";
Modality modality = new Modality();
// attach 2 procedure steps to p1
ModalityProcedureStep ps11 = new ModalityProcedureStep(p1, description, modality);
ModalityProcedureStep ps12 = new ModalityProcedureStep(p1, description, modality);
// expect that each ps is only related to itself
Assert.IsEmpty(ps11.GetRelatedProcedureSteps());
Assert.IsEmpty(ps12.GetRelatedProcedureSteps());
}
public void Test_Cancel_InProgress()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
procedure.Cancel();
}
public void Test_CanExecute_InProgress()
{
Order order = new Order();
DiscontinueOrderOperation op = new DiscontinueOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
Assert.AreEqual(OrderStatus.IP, order.Status);
Assert.IsTrue(op.CanExecute(order));
}
public void Test_IsTerminatedTrue()
{
var procedure = new Procedure();
procedure.Cancel();
Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
procedure.Complete(Platform.Time);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
procedure = new Procedure();
procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
Assert.IsTrue(procedure.IsTerminated);
}
public void Test_CanExecute_Discontinue()
{
Order order = new Order();
CancelOrderOperation op = new CancelOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
order.Discontinue(new OrderCancelInfo());
Assert.AreEqual(OrderStatus.DC, order.Status);
Assert.IsFalse(op.CanExecute(order));
}
public void Test_Complete()
{
Procedure procedure = new Procedure();
Report report = new Report(procedure);
ReportPart reportPart = new ReportPart(report, 0);
// This modality procedure step is created such that when the procedure tries to update its status
// the detection of no ModalityProcedureSteps makes any procedure trying to update its status set itself
// to discontinued, which for this test, is undesirable, this situation will probably never happen
// in practice.
ModalityProcedureStep modalityStep = new ModalityProcedureStep(procedure, "New modality.", new Modality());
InterpretationStep previousStep = new InterpretationStep(procedure);
previousStep.ReportPart = reportPart;
PublicationStep procedureStep = new PublicationStep(previousStep);
procedureStep.Start(new Staff());
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
Assert.AreEqual(0, procedureStep.ReportPart.Index);
Assert.AreEqual(ReportPartStatus.D, procedureStep.ReportPart.Status);
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return p.Status == ProcedureStatus.IP;
}));
procedureStep.Complete();
Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
Assert.AreEqual(ReportPartStatus.F, procedureStep.ReportPart.Status);
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return p.Status == ProcedureStatus.CM;
}));
Assert.IsTrue(procedureStep.AllProcedures.TrueForAll(
delegate(Procedure p)
{
return p.EndTime == procedureStep.EndTime;
}));
}
public void Test_Schedule_PreStep_And_SchedulingOffset()
{
var procedure = new Procedure(new ProcedureType(), "111", "1.111");
var protocolStep = new ProtocolAssignmentStep(new Protocol(procedure));
procedure.AddProcedureStep(protocolStep);
var registrationStep = new RegistrationProcedureStep(procedure);
var modalityStep = new ModalityProcedureStep(procedure, "description", new Modality());
var documentationStep = new DocumentationProcedureStep(procedure);
var reportingStep = new ConcreteReportingProcedureStep(procedure);
Assert.IsNull(protocolStep.Scheduling.StartTime);
Assert.IsNull(registrationStep.Scheduling.StartTime);
Assert.IsNull(modalityStep.Scheduling.StartTime);
Assert.IsNull(documentationStep.Scheduling.StartTime);
Assert.IsNull(reportingStep.Scheduling.StartTime);
var now = DateTime.Now;
procedure.Schedule(now);
Assert.AreEqual(now.Truncate(DateTimePrecision.Minute), procedure.ScheduledStartTime);
Assert.AreEqual(protocolStep.CreationTime, protocolStep.Scheduling.StartTime);
Assert.AreEqual(procedure.ScheduledStartTime, registrationStep.Scheduling.StartTime);
Assert.AreEqual(procedure.ScheduledStartTime, modalityStep.Scheduling.StartTime);
Assert.IsNull(documentationStep.Scheduling.StartTime);
Assert.IsNull(reportingStep.Scheduling.StartTime);
}
public void Test_Schedule_InProgress()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
procedure.Schedule(Platform.Time);
}
public void Execute(ModalityProcedureStep mps, DateTime? discontinueTime, IWorkflow workflow)
{
mps.Discontinue(discontinueTime);
TryAutoCheckOut(mps.Procedure, discontinueTime);
}
public void Test_Cancel_Completed()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Complete(DateTime.Now);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
procedure.Cancel();
}
public void Discontinue()
{
var procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
}
public void Test_PerformedTime_NoneCompleted()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
Assert.IsNull(procedure.PerformedTime);
}
private static void AddProcedureSteps(Procedure procedure, int numMps)
{
Modality m = new Modality("01", "CT", procedure.PerformingFacility, null, null);
for (int s = 0; s < numMps; s++)
{
ModalityProcedureStep step = new ModalityProcedureStep();
step.Description = "MPS 10" + s;
step.Modality = m;
procedure.AddProcedureStep(step);
}
}
public void Test_AddProcedureStep_StepNotScheduling()
{
var procedure = new Procedure();
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
procedure.AddProcedureStep(procedureStep);
}
public void Test_PerformedTime()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
ps1.Start(new Staff());
ps1.Complete(Platform.Time);
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
ps2.Start(new Staff());
ps2.Complete(Platform.Time + TimeSpan.FromDays(1));
var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());
ps3.Start(new Staff());
ps3.Complete(Platform.Time + TimeSpan.FromDays(2));
var ps4 = new ModalityProcedureStep(procedure, "ps4", new Modality());
ps4.Start(new Staff());
ps4.Complete(Platform.Time + TimeSpan.FromDays(3));
Assert.AreEqual(ps4.EndTime, procedure.PerformedTime);
}
public void Test_GetProcedureStep()
{
var procedure = new Procedure();
Assert.IsNull(procedure.GetProcedureStep(delegate { return true; }));
var ps1 = new DocumentationProcedureStep(procedure);
var ps2 = new ModalityProcedureStep(procedure, "new Modality", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "new Modality", new Modality());
var ps4 = new ConcreteReportingProcedureStep(procedure);
Assert.IsNull(procedure.GetProcedureStep(delegate { return false; }));
Assert.AreEqual(ps1, procedure.GetProcedureStep(ps => ps is DocumentationProcedureStep));
Assert.AreEqual(ps2, procedure.GetProcedureStep(ps => ps is ModalityProcedureStep));
Assert.AreEqual(ps4, procedure.GetProcedureStep(ps => ps is ReportingProcedureStep));
Assert.IsNull(procedure.GetProcedureStep(ps => ps is ProtocolProcedureStep));
}
public void Test_IsTerminatedFalse()
{
var procedure = new Procedure();
Assert.IsFalse(procedure.IsTerminated);
var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
procedureStep.Start(new Staff());
Assert.IsFalse(procedure.IsTerminated);
}
public void Test_GetProcedureSteps()
{
var procedure = new Procedure();
Assert.IsEmpty(procedure.GetProcedureSteps(delegate { return true; }));
var ps1 = new DocumentationProcedureStep(procedure);
var ps2 = new ModalityProcedureStep(procedure, "1", new Modality());
var ps3 = new ModalityProcedureStep(procedure, "2", new Modality());
var ps4 = new ProtocolAssignmentStep();
procedure.AddProcedureStep(ps4);
Assert.AreEqual(4, procedure.GetProcedureSteps(delegate { return true; }).Count);
Assert.IsEmpty(procedure.GetProcedureSteps(delegate { return false; }));
Assert.AreEqual(1, procedure.GetProcedureSteps(ps => ps is DocumentationProcedureStep).Count);
Assert.AreEqual(2, procedure.GetProcedureSteps(ps => ps is ModalityProcedureStep).Count);
Assert.AreEqual(0, procedure.GetProcedureSteps(ps => ps is ReportingProcedureStep).Count);
Assert.AreEqual(1, procedure.GetProcedureSteps(ps => ps is ProtocolProcedureStep).Count);
}
public void Test_CanExecute_Complete()
{
Order order = new Order();
CancelOrderOperation op = new CancelOrderOperation();
Procedure procedure = new Procedure();
ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
order.AddProcedure(procedure);
step.Start(new Staff());
procedure.Complete(DateTime.Now);
order.UpdateStatus();
Assert.AreEqual(OrderStatus.CM, order.Status);
Assert.IsFalse(op.CanExecute(order));
}
public void Test_IsPerformed_NonePerformed()
{
var procedure = new Procedure();
var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
ps1.Start(new Staff());
var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
Assert.IsFalse(procedure.IsPerformed);
}
public void Test_Schedule_Complete()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Complete(DateTime.Now);
Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
procedure.Schedule(Platform.Time);
}
public void Test_Cancel_Discontinued()
{
var procedure = new Procedure();
var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
ps.Start(new Staff());
procedure.Discontinue();
Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
procedure.Cancel();
}
