/// <summary>
/// All pertinent data other than the Profiles gets copied from otherPatient to thisPatient
/// </summary>
/// <param name="thisPatient"></param>
/// <param name="otherPatient"></param>
/// <param name="context"></param>
static private void ReconnectRelatedPatientInformation(Patient thisPatient, Patient otherPatient, IPersistenceContext context)
{
foreach (PatientNote note in otherPatient.Notes)
{
thisPatient.AddNote(note);
}
OrderSearchCriteria orderCriteria = new OrderSearchCriteria();
orderCriteria.Patient.EqualTo(otherPatient);
IList<Order> otherOrders = context.GetBroker<IOrderBroker>().Find(orderCriteria);
foreach (Order order in otherOrders)
{
order.Patient = thisPatient;
}
VisitSearchCriteria visitCriteria = new VisitSearchCriteria();
visitCriteria.Patient.EqualTo(otherPatient);
IList<Visit> otherVisits = context.GetBroker<IVisitBroker>().Find(visitCriteria);
foreach (Visit visit in otherVisits)
{
visit.Patient = thisPatient;
}
// TODO: delete the otherPatient
}
static public bool PatientIdentifiersFromIdenticalInformationAuthority(Patient thisPatient, Patient otherPatient)
{
foreach (PatientProfile x in thisPatient.Profiles)
foreach (PatientProfile y in otherPatient.Profiles)
if (x.Mrn.AssigningAuthority.Equals(y.Mrn.AssigningAuthority))
return true;
return false;
}
static public void ReconcileBetweenInformationAuthorities(Patient thisPatient, Patient otherPatient, IPersistenceContext context)
{
if (Utility.PatientIdentifiersFromIdenticalInformationAuthority(thisPatient, otherPatient))
throw new PatientReconciliationException("assigning authorities not identical conflict - cannot reconcile");
// copy patient profiles over
foreach (PatientProfile profile in otherPatient.Profiles)
thisPatient.AddProfile(profile);
ReconnectRelatedPatientInformation(thisPatient, otherPatient, context);
}
/// <summary>
/// The specified visit and its associated orders get moved from otherPatient to thisPatient
/// </summary>
/// <param name="thisPatient"></param>
/// <param name="otherPatient"></param>
/// <param name="visit"></param>
/// <param name="context"></param>
static public void MoveVisit(Patient thisPatient, Patient otherPatient, Visit visit, IPersistenceContext context)
{
var orderCriteria = new OrderSearchCriteria();
orderCriteria.Visit.EqualTo(visit);
var visitOrders = context.GetBroker<IOrderBroker>().Find(orderCriteria);
foreach (var order in visitOrders)
{
order.Patient = thisPatient;
}
visit.Patient = thisPatient;
}
private void RemoveConflicts(Patient patient, IList<PatientProfileMatch> matches)
{
IList<PatientProfileMatch> conflicts = new List<PatientProfileMatch>();
foreach (PatientProfile existingReconciledProfile in patient.Profiles)
{
IdentifyConflictsForSiteFromProposedMatches(existingReconciledProfile, matches, conflicts);
}
foreach (PatientProfileMatch conflict in conflicts)
{
matches.Remove(conflict);
}
}
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 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;
}
/// <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;
}
/// <summary>
/// Finds the visit specified in the requisition, or if no visit is specified, auto-generates a visit.
/// </summary>
/// <param name="requisition"></param>
/// <param name="patient"></param>
/// <param name="orderingFacility"></param>
/// <returns></returns>
private Visit FindOrCreateVisit(OrderRequisition requisition, Patient patient, Facility orderingFacility, string accessionNumber)
{
if (requisition.Visit != null && requisition.Visit.VisitRef != null)
{
return this.PersistenceContext.Load<Visit>(requisition.Visit.VisitRef, EntityLoadFlags.Proxy);
}
// if Visit Workflow is disabled, then we must auto-generate a "dummy" visit in order to keep the system happy
// the user will never see this dummy visit
if (!new WorkflowConfigurationReader().EnableVisitWorkflow)
{
var patientClasses = PersistenceContext.GetBroker<IEnumBroker>().Load<PatientClassEnum>(false);
// create a visit using the minimum possible amount of information
var visit = new Visit
{
Patient = patient,
VisitNumber = new VisitNumber(accessionNumber, orderingFacility.InformationAuthority),
Status = VisitStatus.AA,
AdmitTime = Platform.Time,
Facility = orderingFacility,
PatientClass = CollectionUtils.FirstElement(patientClasses)
};
this.PersistenceContext.Lock(visit, DirtyState.New);
return visit;
}
throw new RequestValidationException("A visit is required.");
}
public AddPatientResponse AddPatient(AddPatientRequest request)
{
var profile = new PatientProfile();
// check if we should auto-generate the MRN
var workflowConfig = new WorkflowConfigurationReader();
if (workflowConfig.AutoGenerateMrn)
{
var authorities = PersistenceContext.GetBroker<IEnumBroker>().Load<InformationAuthorityEnum>(false);
// just use the first Information Authority (there is typically only one in this case)
profile.Mrn.AssigningAuthority = CollectionUtils.FirstElement(authorities);
profile.Mrn.Id = PersistenceContext.GetBroker<IMrnBroker>().GetNext();
}
var patient = new Patient();
patient.AddProfile(profile);
UpdateHelper(profile, request.PatientDetail, true, true, !workflowConfig.AutoGenerateMrn);
PersistenceContext.Lock(patient, DirtyState.New);
LogicalHL7Event.PatientCreated.EnqueueEvents(profile);
PersistenceContext.SynchState();
var assembler = new PatientProfileAssembler();
return new AddPatientResponse(assembler.CreatePatientProfileSummary(profile, PersistenceContext));
}
static public void ReconcileWithinInformationAuthority(Patient thisPatient, Patient otherPatient, IPersistenceContext context)
{
ReconnectRelatedPatientInformation(thisPatient, otherPatient, context);
}