/// <summary>
/// Constructor.
/// </summary>
/// <param name="reason"></param>
/// <param name="cancelledBy"></param>
public OrderCancelInfo(OrderCancelReasonEnum reason, Staff cancelledBy)
{
CustomInitialize();
_reason = reason;
_cancelledBy = cancelledBy;
}
public StaffDetail CreateStaffDetail(Staff staff, IPersistenceContext context)
{
PersonNameAssembler assembler = new PersonNameAssembler();
StaffGroupAssembler groupAssembler = new StaffGroupAssembler();
EmailAddressAssembler emailAssembler = new EmailAddressAssembler();
TelephoneNumberAssembler telephoneAssembler = new TelephoneNumberAssembler();
AddressAssembler addressAssembler = new AddressAssembler();
return new StaffDetail(
staff.GetRef(),
staff.Id,
EnumUtils.GetEnumValueInfo(staff.Type),
assembler.CreatePersonNameDetail(staff.Name),
EnumUtils.GetEnumValueInfo(staff.Sex, context),
staff.Title,
staff.LicenseNumber,
staff.BillingNumber,
CollectionUtils.Map<TelephoneNumber, TelephoneDetail>(
staff.TelephoneNumbers,
delegate(TelephoneNumber tn) { return telephoneAssembler.CreateTelephoneDetail(tn, context); }),
CollectionUtils.Map<Address, AddressDetail>(
staff.Addresses,
delegate(Address a) { return addressAssembler.CreateAddressDetail(a, context); }),
CollectionUtils.Map<EmailAddress, EmailAddressDetail>(
staff.EmailAddresses,
delegate(EmailAddress ea) { return emailAssembler.CreateEmailAddressDetail(ea, context); }),
CollectionUtils.Map<StaffGroup, StaffGroupSummary>(
staff.Groups,
delegate(StaffGroup group) { return groupAssembler.CreateSummary(group); }),
ExtendedPropertyUtils.Copy(staff.ExtendedProperties),
staff.Deactivated,
staff.UserName);
}
public void UpdateCannedText(CannedText cannedText, CannedTextDetail detail, Staff owner, IPersistenceContext context)
{
cannedText.Name = detail.Name;
cannedText.Category = detail.Category;
cannedText.Staff = detail.IsPersonal ? owner : null;
cannedText.StaffGroup = detail.IsGroup ? context.Load<StaffGroup>(detail.StaffGroup.StaffGroupRef, EntityLoadFlags.Proxy) : null;
cannedText.Text = detail.Text;
}
/// <summary>
/// Marks this posting as being acknowledged.
/// </summary>
/// <param name="acknowledgedBy"></param>
protected virtual internal void Acknowledge(Staff acknowledgedBy)
{
if(_isAcknowledged)
throw new WorkflowException("Already acknowledged.");
_acknowledgedBy = new NoteAcknowledgement(acknowledgedBy, Platform.Time);
_isAcknowledged = true;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="reason"></param>
/// <param name="cancelledBy"></param>
/// <param name="comment"></param>
public OrderCancelInfo(OrderCancelReasonEnum reason, Staff cancelledBy, string comment)
{
CustomInitialize();
_reason = reason;
_cancelledBy = cancelledBy;
_comment = comment;
}
public PatientNote CreateNote(PatientNoteDetail detail, Staff author, IPersistenceContext context)
{
PatientNoteCategory category = context.Load<PatientNoteCategory>(detail.Category.NoteCategoryRef, EntityLoadFlags.Proxy);
PatientNote note = new PatientNote(author, category, detail.Comment);
note.ValidRange.Until = detail.ValidRangeUntil;
return note;
}
/// <summary>
/// Constructor for creating a new patient note.
/// </summary>
/// <param name="author"></param>
/// <param name="category"></param>
/// <param name="comment"></param>
public PatientNote(Staff author, PatientNoteCategory category, string comment)
{
_author = author;
_category = category;
_comment = comment;
// valid from now indefinitely
_creationTime = Platform.Time;
_validRange = new DateTimeRange(_creationTime, null);
}
public StaffSummary CreateStaffSummary(Staff staff, IPersistenceContext context)
{
if (staff == null)
return null;
return new StaffSummary(staff.GetRef(), staff.Id,
EnumUtils.GetEnumValueInfo(staff.Type),
new PersonNameAssembler().CreatePersonNameDetail(staff.Name),
staff.Deactivated);
}
/// <summary>
/// Constructor for creating a new note with recipients.
/// </summary>
/// <param name="category"></param>
/// <param name="author"></param>
/// <param name="onBehalfOf"></param>
/// <param name="body"></param>
/// <param name="urgent"></param>
public Note(string category, Staff author, StaffGroup onBehalfOf, string body, bool urgent)
{
_category = category;
_author = author;
_onBehalfOfGroup = onBehalfOf;
_body = body;
_urgent = urgent;
_postings = new HashedSet<NotePosting>();
_creationTime = Platform.Time;
}
public override ProcedureStep Reassign(Staff performer)
{
var reassign = base.Reassign(performer).Downcast<VerificationStep>();
// When reassigning a verification step to another staff, we should reassign the supervisor as well
// so the report part will be reviewed by the appropriate staff radiologist
if (reassign.ReportPart != null && reassign.ReportPart.Supervisor != null)
reassign.ReportPart.Supervisor = performer;
return reassign;
}
public void UpdateOrderFromRequisition(Order order, OrderRequisition requisition, Staff currentStaff, IPersistenceContext context)
{
// only certain properties of an order may be updated from a requisition
// Patient cannot not be updated
// DiagnosticService cannot be updated
// OrderingFacility cannot be updated
// do not update the individual procedures, as this is done separately - see UpdateProcedureFromRequisition
// Some properties cannot be updated if the procedure is terminated
if (!order.IsTerminated)
{
order.Visit = context.Load<Visit>(requisition.Visit.VisitRef, EntityLoadFlags.Proxy);
order.SchedulingRequestTime = requisition.SchedulingRequestTime;
order.OrderingPractitioner = context.Load<ExternalPractitioner>(
requisition.OrderingPractitioner.PractitionerRef, EntityLoadFlags.Proxy);
order.ReasonForStudy = requisition.ReasonForStudy;
order.Priority = EnumUtils.GetEnumValue<OrderPriority>(requisition.Priority);
// wipe out and reset the result recipients
order.ResultRecipients.Clear();
CollectionUtils.Map<ResultRecipientDetail, ResultRecipient>(
requisition.ResultRecipients,
s => new ResultRecipient(
context.Load<ExternalPractitionerContactPoint>(s.ContactPoint.ContactPointRef, EntityLoadFlags.Proxy),
EnumUtils.GetEnumValue<ResultCommunicationMode>(s.PreferredCommunicationMode))).ForEach(r => order.ResultRecipients.Add(r));
}
// synchronize Order.Attachments from order requisition
var attachmentAssembler = new OrderAttachmentAssembler();
attachmentAssembler.Synchronize(order.Attachments, requisition.Attachments, currentStaff, context);
// synchronize Order.Notes from order requisition
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, requisition.Notes, currentStaff, context);
if (requisition.ExtendedProperties != null)
{
ExtendedPropertyUtils.Update(order.ExtendedProperties, requisition.ExtendedProperties);
}
}
/// <summary>
/// Constructor that does not specify an explicit list of procedures.
/// </summary>
/// <param name="enteredTime"></param>
/// <param name="enteredBy"></param>
/// <param name="enteredComment"></param>
/// <param name="accessionNumber"></param>
/// <param name="patient"></param>
/// <param name="visit"></param>
/// <param name="diagnosticService"></param>
/// <param name="reasonForStudy"></param>
/// <param name="priority"></param>
/// <param name="orderingFacility"></param>
/// <param name="performingFacility"></param>
/// <param name="schedulingRequestTime"></param>
/// <param name="orderingPractitioner"></param>
/// <param name="resultRecipients"></param>
public OrderCreationArgs(DateTime enteredTime, Staff enteredBy, string enteredComment, string accessionNumber,
Patient patient, Visit visit, DiagnosticService diagnosticService, string reasonForStudy, OrderPriority priority,
Facility orderingFacility, Facility performingFacility, DateTime? schedulingRequestTime, ExternalPractitioner orderingPractitioner,
IList<ResultRecipient> resultRecipients)
{
EnteredTime = enteredTime;
EnteredBy = enteredBy;
EnteredComment = enteredComment;
AccessionNumber = accessionNumber;
Patient = patient;
Visit = visit;
DiagnosticService = diagnosticService;
ReasonForStudy = reasonForStudy;
Priority = priority;
OrderingFacility = orderingFacility;
PerformingFacility = performingFacility;
SchedulingRequestTime = schedulingRequestTime;
OrderingPractitioner = orderingPractitioner;
ResultRecipients = resultRecipients;
}
public void Synchronize(Patient patient, ICollection<PatientNoteDetail> sourceList, Staff newNoteAuthor, IPersistenceContext context)
{
foreach (PatientNoteDetail noteDetail in sourceList)
{
if(noteDetail.PatientNoteRef == null)
{
patient.AddNote(CreateNote(noteDetail, newNoteAuthor, context));
}
else
{
PatientNote note = CollectionUtils.SelectFirst(patient.Notes,
delegate(PatientNote n) { return n.GetRef().Equals(noteDetail.PatientNoteRef, true); });
if(note != null)
{
UpdateNote(note, noteDetail);
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="note"></param>
/// <param name="order"></param>
/// <param name="patient"></param>
/// <param name="patientProfile"></param>
/// <param name="noteAuthor"></param>
/// <param name="recipients"></param>
/// <param name="diagnosticServiceName"></param>
/// <param name="isAcknowledged"></param>
public OrderNoteboxItem(Note note, Order order, Patient patient, PatientProfile patientProfile,
Staff noteAuthor, IList recipients,
string diagnosticServiceName, bool isAcknowledged)
{
_noteRef = note.GetRef();
_orderRef = order.GetRef();
_patientRef = patient.GetRef();
_patientProfileRef = patientProfile.GetRef();
_mrn = patientProfile.Mrn;
_patientName = patientProfile.Name;
_dateOfBirth = patientProfile.DateOfBirth;
_accessionNumber = order.AccessionNumber;
_diagnosticServiceName = diagnosticServiceName;
_category = note.Category;
_urgent = note.Urgent;
_postTime = note.PostTime;
_author = noteAuthor;
_onBehalfOfGroup = note.OnBehalfOfGroup;
_isAcknowledged = isAcknowledged;
_recipients = recipients;
}
public ProcedureStepPerformer(Staff staff)
{
Platform.CheckForNullReference(staff, "staff");
_staff = staff;
}
public void UpdateProcedureFromRequisition(Procedure procedure, ProcedureRequisition requisition, Staff currentUserStaff, IPersistenceContext context)
{
// check if the procedure was cancelled
if (requisition.Cancelled)
{
if (procedure.Status == ProcedureStatus.SC)
{
// if RP is still scheduled, cancel it
procedure.Cancel();
}
else if (procedure.Status == ProcedureStatus.IP)
{
// if RP in-progress, discontinue it
procedure.Discontinue();
}
// early exit - nothing else to update
return;
}
// The following properties are appropriate only for procedures in SC status.
if (!IsProcedureModifiable(procedure))
return;
procedure.Schedule(requisition.ScheduledTime, requisition.ScheduledDuration);
procedure.SchedulingCode = EnumUtils.GetEnumValue<SchedulingCodeEnum>(requisition.SchedulingCode, context);
procedure.PerformingFacility = context.Load<Facility>(requisition.PerformingFacility.FacilityRef, EntityLoadFlags.Proxy);
procedure.PerformingDepartment = requisition.PerformingDepartment == null ? null
: context.Load<Department>(requisition.PerformingDepartment.DepartmentRef, EntityLoadFlags.Proxy);
// if the requisition explicitly specifies a modality, assign that modality to all MPS
// (we ignore the fact that the procedure plan can theoretically contain modality procedures steps spanning multiple
// DICOM modalities, since in the small clinic use-case, each procedure type generally only has a single MPS)
if (requisition.Modality != null)
{
foreach (var mps in procedure.ModalityProcedureSteps)
{
mps.Modality = context.Load<Modality>(requisition.Modality.ModalityRef, EntityLoadFlags.Proxy);
}
}
procedure.Laterality = EnumUtils.GetEnumValue<Laterality>(requisition.Laterality);
procedure.Portable = requisition.PortableModality;
if (requisition.CheckedIn && procedure.IsPreCheckIn)
{
procedure.CheckIn(currentUserStaff, null);
}
else if (!requisition.CheckedIn && procedure.IsCheckedIn)
{
procedure.RevertCheckIn();
}
}
public PerformedProcedureStep(Staff performingStaff, DateTime? startTime)
: base(new ProcedureStepPerformer(performingStaff), startTime)
{
}
public void UpdateStaff(StaffDetail detail, Staff staff, bool updateElectiveGroups, bool updateNonElectiveGroups, IPersistenceContext context)
{
PersonNameAssembler assembler = new PersonNameAssembler();
EmailAddressAssembler emailAssembler = new EmailAddressAssembler();
TelephoneNumberAssembler telephoneAssembler = new TelephoneNumberAssembler();
AddressAssembler addressAssembler = new AddressAssembler();
staff.Id = detail.StaffId;
staff.Type = EnumUtils.GetEnumValue<StaffTypeEnum>(detail.StaffType, context);
assembler.UpdatePersonName(detail.Name, staff.Name);
staff.Sex = EnumUtils.GetEnumValue<Sex>(detail.Sex);
staff.Title = detail.Title;
staff.LicenseNumber = detail.LicenseNumber;
staff.BillingNumber = detail.BillingNumber;
staff.Deactivated = detail.Deactivated;
staff.UserName = detail.UserName;
staff.TelephoneNumbers.Clear();
if (detail.TelephoneNumbers != null)
{
foreach (TelephoneDetail phoneDetail in detail.TelephoneNumbers)
{
staff.TelephoneNumbers.Add(telephoneAssembler.CreateTelephoneNumber(phoneDetail));
}
}
staff.Addresses.Clear();
if (detail.Addresses != null)
{
foreach (AddressDetail addressDetail in detail.Addresses)
{
staff.Addresses.Add(addressAssembler.CreateAddress(addressDetail));
}
}
staff.EmailAddresses.Clear();
if (detail.EmailAddresses != null)
{
foreach (EmailAddressDetail emailAddressDetail in detail.EmailAddresses)
{
staff.EmailAddresses.Add(emailAssembler.CreateEmailAddress(emailAddressDetail));
}
}
ExtendedPropertyUtils.Update(staff.ExtendedProperties, detail.ExtendedProperties);
if (updateElectiveGroups)
{
// update elective groups
UpdateStaffGroups(detail, staff,
delegate(StaffGroupSummary summary) { return summary.IsElective; },
delegate(StaffGroup group) { return group.Elective; },
context);
}
if (updateNonElectiveGroups)
{
// update non-elective groups
UpdateStaffGroups(detail, staff,
delegate(StaffGroupSummary summary) { return !summary.IsElective; },
delegate(StaffGroup group) { return !group.Elective; },
context);
}
}
/// <summary>
/// Throws an exception if the current user does not have access to edit specified staff.
/// </summary>
/// <param name="staff"></param>
private void CheckWriteAccess(Staff staff)
{
// users with Admin.Data.Staff token can access any staff
if (Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.Staff))
return;
// users can update their own staff profile with the Update token
if (staff.UserName == this.CurrentUser && Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.StaffProfile.Update))
return;
throw new System.Security.SecurityException(SR.ExceptionUserNotAuthorized);
}
/// <summary>
/// Throws an exception if the current user does not have access to edit specified staff.
/// </summary>
/// <param name="staff"></param>
private void CheckReadAccess(Staff staff)
{
// users with Admin.Data.Staff token can access any staff
if (Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.Staff))
return;
// users can access their own staff profile
if (staff.UserName == this.CurrentUser)
return;
throw new System.Security.SecurityException(SR.ExceptionUserNotAuthorized);
}
public AddStaffResponse AddStaff(AddStaffRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.StaffDetail, "StaffDetail");
// if trying to associate with a user account, check the account is free
if(!string.IsNullOrEmpty(request.StaffDetail.UserName))
{
ValidateUserNameFree(request.StaffDetail.UserName);
}
// create new staff
var staff = new Staff();
// set properties from request
var assembler = new StaffAssembler();
var groupsEditable = Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.StaffGroup);
assembler.UpdateStaff(request.StaffDetail,
staff,
groupsEditable,
groupsEditable,
PersistenceContext);
PersistenceContext.Lock(staff, DirtyState.New);
// ensure the new staff is assigned an OID before using it in the return value
PersistenceContext.SynchState();
return new AddStaffResponse(assembler.CreateStaffSummary(staff, PersistenceContext));
}
public CannedText CreateCannedText(CannedTextDetail detail, Staff owner, IPersistenceContext context)
{
CannedText newCannedText = new CannedText();
UpdateCannedText(newCannedText, detail, owner, context);
return newCannedText;
}
public ModalityPerformedProcedureStep(Staff performingStaff, DateTime? startTime)
: base(performingStaff, startTime)
{
_dicomSeries = new HashedSet<ClearCanvas.Healthcare.DicomSeries>();
}
private static void UpdateStaffGroups(StaffDetail detail, Staff staff, Predicate<StaffGroupSummary> p1, Predicate<StaffGroup> p2,
IPersistenceContext context)
{
// create a helper to sync staff group membership
CollectionSynchronizeHelper<StaffGroup, StaffGroupSummary> helper =
new CollectionSynchronizeHelper<StaffGroup, StaffGroupSummary>(
delegate(StaffGroup group, StaffGroupSummary summary)
{
return group.GetRef().Equals(summary.StaffGroupRef, true);
},
delegate(StaffGroupSummary groupSummary, ICollection<StaffGroup> groups)
{
StaffGroup group = context.Load<StaffGroup>(groupSummary.StaffGroupRef, EntityLoadFlags.Proxy);
group.AddMember(staff);
},
delegate
{
// do nothing
},
delegate(StaffGroup group, ICollection<StaffGroup> groups)
{
group.RemoveMember(staff);
}
);
helper.Synchronize(
CollectionUtils.Select(staff.Groups, p2),
CollectionUtils.Select(detail.Groups, p1));
}
/// <summary>
/// Add a member to this staff group.
/// </summary>
/// <param name="member"></param>
public virtual void AddMember(Staff member)
{
_members.Add(member);
member.Groups.Add(this);
}
/// <summary>
/// Remove a member from this staff group.
/// </summary>
/// <param name="member"></param>
public virtual void RemoveMember(Staff member)
{
_members.Remove(member);
member.Groups.Remove(this);
}
public bool CanEdit(Staff staff)
{
return this.State == ActivityStatus.IP && this.PerformingStaff == staff;
}
public PerformedProcedureStep(Staff performingStaff)
: base(new ProcedureStepPerformer(performingStaff))
{
}
/// <summary>
/// Saves the report, and validates that a supervisor is present if the current user does not have 'unsupervised reporting' permissions.
/// </summary>
/// <param name="reportPartExtendedProperties"></param>
/// <param name="step"></param>
/// <param name="supervisor"></param>
/// <param name="supervisorValidationRequired"></param>
private void SaveReportHelper(Dictionary<string, string> reportPartExtendedProperties, ReportingProcedureStep step, Staff supervisor, bool supervisorValidationRequired)
{
if (supervisorValidationRequired
&& Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.SubmitForReview)
&& Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.OmitSupervisor) == false
&& supervisor == null)
{
throw new SupervisorValidationException();
}
var saveReportOp = new Operations.SaveReport();
saveReportOp.Execute(step, reportPartExtendedProperties, supervisor);
}
private static void SaveReportHelper(TranscriptionStep step, Dictionary<string, string> reportPartExtendedProperties, Staff supervisor)
{
var op = new TranscriptionOperations.SaveTranscription();
op.Execute(step, reportPartExtendedProperties, supervisor);
}
public ReportingPerformedProcedureStep(Staff performingStaff)
:base(performingStaff)
{
}
/// <summary>
/// Check in the procedure, optionally specifying a check-in time. If not specified,
/// the current time is assumed.
/// </summary>
public virtual void CheckIn(Staff checkInStaff, DateTime? checkInTime)
{
_procedureCheckIn.CheckIn(checkInTime);
// start the registration step, if not started
var regStep = GetProcedureStep(ps => ps.Is<RegistrationProcedureStep>());
if (regStep != null && regStep.State == ActivityStatus.SC)
regStep.Start(checkInStaff, checkInTime);
}
public ReportingPerformedProcedureStep(Staff performingStaff)
: base(performingStaff)
{
}