/// <summary>
/// Creates the alert.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="name">The name.</param>
/// <param name="note">The note.</param>
/// <param name="cdsIdentifier">The CDS identifier.</param>
/// <returns>
/// A PatientAlert.
/// </returns>
public PatientAlert CreateAlert( Patient patient, string name, string note, string cdsIdentifier )
{
var patientAlert = new PatientAlert(patient, name, note, cdsIdentifier);
_patientAlertRepository.MakePersistent(patientAlert);
return patientAlert;
}
/// <summary>
/// Creates the medication.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="medicationCodeCodedConcept">The medication code coded concept.</param>
/// <param name="provenance">The provenance.</param>
/// <returns>A Medication.</returns>
public Medication CreateMedication(Patient patient, CodedConcept medicationCodeCodedConcept, Provenance provenance)
{
var medication = new Medication(patient, medicationCodeCodedConcept, provenance);
_medicationRepository.MakePersistent(medication);
return medication;
}
/// <summary>
/// Initializes a new instance of the <see cref="Medication"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="medicationCodeCodedConcept">The medication code coded concept.</param>
/// <param name="rootMedicationCodedConcept">The root medication coded concept.</param>
protected internal Medication( Patient patient, CodedConcept medicationCodeCodedConcept, CodedConcept rootMedicationCodedConcept )
{
Check.IsNotNull ( patient, "Patient is required." );
Check.IsNotNull ( medicationCodeCodedConcept, () => MedicationCodeCodedConcept );
Check.IsNotNull ( rootMedicationCodedConcept, () => RootMedicationCodedConcept );
_patient = patient;
_medicationCodeCodedConcept = medicationCodeCodedConcept;
_rootMedicationCodedConcept = rootMedicationCodedConcept;
}
internal Allergy( Patient patient, AllergyStatus allergyStatus, CodedConcept allergenCodedConcept )
{
Check.IsNotNull ( patient, () => Patient );
Check.IsNotNull ( allergyStatus, () => AllergyStatus );
Check.IsNotNull ( allergenCodedConcept, () => AllergenCodedConcept );
_allergyReactions = new List<AllergyReaction> ();
_patient = patient;
_allergyStatus = allergyStatus;
_allergenCodedConcept = allergenCodedConcept;
}
/// <summary>
/// Generates the unique identifier.
/// </summary>
/// <param name="patient">The patient.</param>
/// <returns>The generated unique identifier.</returns>
public string GenerateUniqueIdentifier(Patient patient)
{
var identifier = patient.Key.ToString();
if (patient.Profile.PatientGender != null && patient.Profile.BirthDate.HasValue)
{
identifier = GenerateUniqueUniqueIdentifier(patient.Name.Last, patient.Profile.PatientGender.Name, patient.Profile.BirthDate.Value);
}
return identifier;
}
/// <summary>
/// Initializes a new instance of the <see cref="PatientAlert"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="name">The name.</param>
/// <param name="note">The note.</param>
/// <param name="cdsIdentifier">The CDS identifier.</param>
protected internal PatientAlert(Patient patient, string name, string note, string cdsIdentifier)
{
Check.IsNotNull ( patient, () => Patient );
Check.IsNotNull ( name, () => Name );
Check.IsNotNullOrWhitespace ( note, () => Note );
Check.IsNotNullOrWhitespace ( cdsIdentifier, () => CdsIdentifier );
_patient = patient;
_name = name;
_note = note;
_cdsIdentifier = cdsIdentifier;
}
/// <summary>
/// Creates the patient document.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="patientDocumentType">Type of the patient document.</param>
/// <param name="document">The document.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns>
/// A PatientDocument.
/// </returns>
public PatientDocument CreatePatientDocument(
Patient patient,
PatientDocumentType patientDocumentType,
byte[] document,
string fileName )
{
var hash = _hashingUtility.ComputeHash ( document );
var patientDocument = new PatientDocument(patient, patientDocumentType, document, fileName, hash);
_patientDocumentRepository.MakePersistent ( patientDocument );
return patientDocument;
}
/// <summary>
/// Initializes a new instance of the <see cref="SelfPayment"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="collectedByStaff">The collected by staff.</param>
/// <param name="money">The money.</param>
/// <param name="paymentMethod">The payment method.</param>
/// <param name="collectedDate">The collected date.</param>
protected internal SelfPayment( Patient patient, Staff collectedByStaff, Money money, PaymentMethod paymentMethod, DateTime? collectedDate )
{
Check.IsNotNull ( patient, () => Patient );
Check.IsNotNull ( collectedByStaff, () => CollectedByStaff );
Check.IsNotNull ( money, () => Money );
Check.IsNotNull ( paymentMethod, () => PaymentMethod );
Check.IsNotNull ( collectedDate, () => CollectedDate );
_patient = patient;
_collectedByStaff = collectedByStaff;
_money = money;
_paymentMethod = paymentMethod;
_collectedDate = collectedDate;
}
/// <summary>
/// Creates the clinical case.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="clinicalCaseProfile">The clinical case profile.</param>
/// <returns>A ClinicalCase.</returns>
public ClinicalCase CreateClinicalCase(
Patient patient,
ClinicalCaseProfile clinicalCaseProfile )
{
Check.IsNotNull(patient, "Patient is required.");
Check.IsNotNull(clinicalCaseProfile, "Clinical case profile is required.");
long mostRecentCaseNumber = _clinicalCaseRepository.GetMostRecentCaseNumber ( patient.Key );
var clinicalCase = new ClinicalCase(patient, clinicalCaseProfile, mostRecentCaseNumber);
_clinicalCaseRepository.MakePersistent ( clinicalCase );
return clinicalCase;
}
/// <summary>
/// Creates the self payment.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="staff">The staff.</param>
/// <param name="money">The money.</param>
/// <param name="paymentMethod">The payment method.</param>
/// <param name="collectedDate">The collected date.</param>
/// <returns>A Self Payment.</returns>
public SelfPayment CreateSelfPayment( Patient patient, Staff staff, Money money, PaymentMethod paymentMethod, DateTime? collectedDate )
{
var selfPayment = new SelfPayment ( patient, staff, money, paymentMethod, collectedDate );
SelfPayment createdSelfPayment = null;
DomainRuleEngine.CreateRuleEngine ( selfPayment, "CreateSelfPaymentRuleSet" )
.Execute ( () =>
{
createdSelfPayment = selfPayment;
_selfPaymentRepository.MakePersistent(createdSelfPayment);
});
return createdSelfPayment;
}
/// <summary>
/// Creates the patient contact.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="firstName">The first name.</param>
/// <param name="lastName">The last name.</param>
/// <returns>
/// A PatientContact.
/// </returns>
public PatientContact CreatePatientContact( Patient patient, string firstName, string lastName )
{
var newPatientContact = new PatientContact ( patient, firstName, lastName );
PatientContact createdPatientContact = null;
DomainRuleEngine.CreateRuleEngine ( newPatientContact, "CreatePatientContactRuleSet" ).Execute (
() =>
{
createdPatientContact = newPatientContact;
_patientContactRepository.MakePersistent ( newPatientContact );
} );
return createdPatientContact;
}
/// <summary>
/// Initializes a new instance of the <see cref="PayorCoverageCache"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="payorCache">The payor cache.</param>
/// <param name="effectiveDateRange">The effective date range.</param>
/// <param name="memberNumber">The member number.</param>
/// <param name="payorSubscriber">The payor subscriber.</param>
/// <param name="payorCoverageCacheType">Type of the payor coverage cache.</param>
protected internal PayorCoverageCache(
Patient patient,
PayorCache payorCache,
DateRange effectiveDateRange,
string memberNumber,
PayorSubscriberCache payorSubscriber,
PayorCoverageCacheType payorCoverageCacheType )
{
Patient = patient;
PayorCache = payorCache;
EffectiveDateRange = effectiveDateRange;
MemberNumber = memberNumber;
PayorSubscriberCache = payorSubscriber;
PayorCoverageCacheType = payorCoverageCacheType;
}
/// <summary>
/// Initializes a new instance of the <see cref="PatientAccessEvent"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="patientAccessEventType">Type of the patient access event.</param>
/// <param name="auditedContextDescription">The audited context description.</param>
/// <param name="note">The note.</param>
public PatientAccessEvent(
Patient patient,
PatientAccessEventType patientAccessEventType,
string auditedContextDescription,
string note )
{
Check.IsNotNull ( patient, "Patient is required." );
Check.IsNotNull ( patientAccessEventType, "Patient access event is required." );
Check.IsNotNull(auditedContextDescription, "Audited context description is required.");
Check.IsNotNullOrWhitespace ( note, "Note is required." );
_patient = patient;
AuditedContextDescription = auditedContextDescription;
_patientAccessEventType = patientAccessEventType;
_note = note;
}
/// <summary>
/// Initializes a new instance of the <see cref="PatientDocument"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="patientDocumentType">Type of the patient document.</param>
/// <param name="document">The document.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="documentHashValue">The document hash value.</param>
protected internal PatientDocument(
Patient patient,
PatientDocumentType patientDocumentType,
byte[] document,
string fileName,
string documentHashValue )
{
Check.IsNotNull ( patient, "Patient is required." );
Check.IsNotNull ( patientDocumentType, "Patient Document Type is required." );
Check.IsNotNull ( document, "Document contents are required." );
Check.IsNotNullOrWhitespace ( fileName, "Filename is required." );
Check.IsNotNullOrWhitespace ( documentHashValue, "Document Hash is required." );
_patient = patient;
_patientDocumentType = patientDocumentType;
_document = document;
_fileName = fileName;
_documentHashValue = documentHashValue;
}
/// <summary>
/// Creates the patient.
/// </summary>
/// <param name="agency">The agency.</param>
/// <param name="patientName">Name of the patient.</param>
/// <param name="patientProfile">The patient profile.</param>
/// <returns>
/// A Patient.
/// </returns>
public Patient CreatePatient(Agency agency, PersonName patientName, PatientProfile patientProfile )
{
var newPatient = new Patient(agency, patientName, patientProfile);
Patient createdPatient = null;
DomainRuleEngine.CreateRuleEngine ( newPatient, "CreatePatientRuleSet" )
.WithContext ( newPatient.Profile )
.Execute(() =>
{
createdPatient = newPatient;
newPatient.UpdateUniqueIdentifier(_patientUniqueIdentifierCalculator.GenerateUniqueIdentifier(newPatient));
_patientRepository.MakePersistent ( newPatient );
DomainEvent.Raise ( new PatientCreatedEvent { Patient = newPatient } );
});
return createdPatient;
}
public void AddAddress_GivenDuplicate_ValidationFailureEventIsRaised()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture ( serviceLocatorFixture );
var eventRaised = false;
DomainEvent.Register<RuleViolationEvent>(p => eventRaised = true);
var agencyMock = new Mock<Agency>();
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var address = new AddressBuilder ()
.WithFirstStreetAddress ( "123 Test Street" )
.WithCityName ( "Testville" )
.WithStateProvince ( new StateProvince () )
.WithPostalCode ( new PostalCode ( "12345" ) )
.Build ();
var patientAddress = new PatientAddressBuilder ()
.WithPatientAddressType ( new PatientAddressType () )
.WithAddress(address)
.Build ();
var patient = new Patient(agencyMock.Object, name, new PatientProfileBuilder().Build());
patient.AddAddress ( patientAddress );
// Exercise
patient.AddAddress(patientAddress);
// Verify
Assert.IsTrue(eventRaised);
}
}
/// <summary>
/// Creates the payor coverage.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="payorCache">The payor cache.</param>
/// <param name="effectiveDateRange">The effective date range.</param>
/// <param name="memberNumber">The member number.</param>
/// <param name="payorSubscriberCache">The payor subscriber cache.</param>
/// <param name="payorCoverageCacheType">Type of the payor coverage cache.</param>
/// <returns>A Payor coverage cache.</returns>
public PayorCoverageCache CreatePayorCoverage(
Patient patient,
PayorCache payorCache,
DateRange effectiveDateRange,
string memberNumber,
PayorSubscriberCache payorSubscriberCache,
PayorCoverageCacheType payorCoverageCacheType )
{
var payorCoverage = new PayorCoverageCache ( patient, payorCache, effectiveDateRange, memberNumber, payorSubscriberCache, payorCoverageCacheType );
PayorCoverageCache createdPayorCoverage = null;
DomainRuleEngine.CreateRuleEngine(payorCoverage, "CreatePayorCoverageRuleSet")
.WithContext ( payorCoverage.PayorCoverageCacheType )
.WithContext ( payorCoverage.EffectiveDateRange )
.Execute(() =>
{
createdPayorCoverage = payorCoverage;
_payorCoverageCacheRepository.MakePersistent(payorCoverage);
});
return createdPayorCoverage;
}
private PatientCharacteristicsType BuildPatientCharacteristics( Patient patient )
{
Check.IsNotNull ( patient.Profile.BirthDate, "Patient's Birthdate cannot be null" );
Debug.Assert ( patient.Profile.BirthDate != null, "patient.BirthDate != null" );
return new PatientCharacteristicsType
{
Dob = patient.Profile.BirthDate.Value.Date.ToString ( "yyyyMMdd" ),
Gender = TransformGenderType ( patient.Profile.PatientGender ),
// This assumes Gender is always provided
GenderSpecified = true
};
}
/// <summary>
/// Creates the allergy.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="allergyStatus">The allergy status.</param>
/// <param name="allergenCodedConcept">The allergen coded concept.</param>
/// <param name="provenance">The provenance.</param>
/// <returns>
/// An Allergy.
/// </returns>
public Allergy CreateAllergy(Patient patient, AllergyStatus allergyStatus, CodedConcept allergenCodedConcept, Provenance provenance)
{
var allergy = new Allergy(patient, allergyStatus, allergenCodedConcept, provenance);
_allergyRepository.MakePersistent(allergy);
return allergy;
}
/// <summary>
/// Initializes a new instance of the <see cref="PatientContact"/> class.
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="firstName">The first name.</param>
/// <param name="lastName">The last name.</param>
protected internal PatientContact( Patient patient, string firstName, string lastName )
{
Check.IsNotNull ( patient, "Patient is required." );
Check.IsNotNullOrWhitespace ( firstName, "First name is required." );
Check.IsNotNullOrWhitespace ( lastName, "Last name is required." );
_patient = patient;
_firstName = firstName;
_lastName = lastName;
_phoneNumbers = new List<PatientContactPhone> ();
_contactTypes = new List<PatientContactContactType> ();
}
/// <summary>
/// Gets the HL7 message.
/// </summary>
/// <param name="keyValues">The key values.</param>
/// <returns>A <see cref="System.String"/></returns>
public string GetHl7Message( Dictionary<string, long> keyValues )
{
var problemKey = keyValues[HttpHandlerQueryStrings.ProblemKey];
var session = _sessionProvider.GetSession ();
_messageLocalDateTime = DateTime.Now;
_problem = session.Get<Problem> ( keyValues[HttpHandlerQueryStrings.ProblemKey] );
Check.IsNotNull ( _problem, string.Format ( "Problem not found for key {0}.", problemKey ) );
// Derive a visit appointment date for a problem associated with multiple visits.
// Return the first minimum Appointment.ScheduledStartDateTime and Visit.Key where the Problem.Key is found.
var queryResult = session.CreateQuery (
@"select min(v.AppointmentDateTimeRange.StartDateTime) as AppointmentStartDateTime, vp.Visit.Key as VisitKey
from VisitProblem as vp
join vp.Visit as v
where vp.Problem.Key = :problemKey
group by vp.Visit.Key" )
.SetParameter ( "problemKey", problemKey )
.List ();
_minimumVisitScheduledStartDateTime = ( DateTime )( ( object[] )queryResult[0] )[0];
_minimumVisitKey = ( long )( ( object[] )queryResult[0] )[1];
VerifyDerivedVisit ();
_clinicalCase = _problem.ClinicalCase;
_patient = _problem.ClinicalCase.Patient;
var dto = new SyndromicSurveillanceDto
{
MshDto = GetMshDto (),
PidDto = GetPidDto (),
EVNDto = GetEvnDto (),
PV1Dto = GetPv1Dto (),
Observations = GetObservations (),
PresentedProblems = GetPresentedProblems ()
};
var helper = IoC.CurrentContainer.Resolve<IMessageHelper<ADT_A01, SyndromicSurveillanceDto>> ();
var factory = IoC.CurrentContainer.Resolve<MessageFactoryBase<ADT_A01, SyndromicSurveillanceDto>>();
AbstractMessage message;
if ( helper != null && factory != null )
{
message = factory.CreateMessage ( dto );
}
else
{
throw new ArgumentException ( "HL7 message helper or factory instances were not created." );
}
return ( new PipeParser () ).Encode ( message );
}
public void Rename_GivenValidName_ValidationFailureEventIsNotRaised()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
bool eventRaised = false;
DomainEvent.Register<RuleViolationEvent> ( p => eventRaised = true );
var agency = new Mock<Agency>();
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var patient = new Patient(agency.Object, name, new PatientProfileBuilder().Build());
var newName = new PersonNameBuilder()
.WithFirst("Fred")
.WithLast("Thomas");
// Exercise
patient.Rename(newName);
// Verify
Assert.IsFalse(eventRaised);
}
}
public void Rename_GivenTheSameName_PatientRenamedEventIsNotRaised()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
bool eventRaised = false;
DomainEvent.Register<PatientRenamedEvent>(p => eventRaised = true);
var agencyMock = new Mock<Agency>();
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var patient = new Patient(agencyMock.Object, name, new PatientProfileBuilder().Build());
// Exercise
patient.Rename(name);
// Verify
Assert.IsFalse(eventRaised);
}
}
private List<OutsidePrescriptionType> BuildOutsidePrescriptionType( Patient patient )
{
if ( patient != null && patient.Medications.Any () )
{
var outsidePrescriptions = new List<OutsidePrescriptionType> ();
var medications = patient.Medications
.Where ( med => med.MedicationStatus.WellKnownName == MedicationStatus.Active )
.ToList ();
Logger.Debug ( "Patient's Medication List contained {0} active Medications.", medications.Count ().ToString () );
medications.ForEach (
medication =>
{
outsidePrescriptions.Add ( TransformRemMedicationIntoOutsidePrescriptionAsFreeText ( medication ) );
Logger.Debug (
"Sending {0} as Free Text OutsidePrescription to NewCrop.",
medication.MedicationCodeCodedConcept.DisplayName );
// TODO: Make the Sending Rx as Mapped Drug Configurable
//outsidePrescriptions.Add ( TransformRemMedicationIntoOutsidePrescriptionAsMappedDrug ( medication ) );
//Logger.Debug ( "Sending {0} as Mapped OutsidePrescription to NewCrop.",
// medication.MedicationCodeCodedConcept.DisplayName );
} );
return outsidePrescriptions;
}
return null;
}
public void Rename_GivenValidName_NameIsChanged()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
var agencyMock = new Mock<Agency>();
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var patient = new Patient(agencyMock.Object, name, new PatientProfileBuilder().Build());
var newName = new PersonNameBuilder()
.WithFirst("Fred")
.WithLast("Thomas");
// Exercise
patient.Rename(newName);
// Verify
Assert.IsTrue(patient.Name == newName);
}
}
private List<PatientAllergyFreeformType> BuildPatientFreeFormAllergies( Patient patient )
{
var allergies = new List<PatientAllergyFreeformType> ();
var drugAllergies = patient.Allergies
.Where (
a => a.AllergyType.WellKnownName == AllergyType.DrugAllergy
&& a.AllergyStatus.WellKnownName == AllergyStatus.Active )
.ToList ();
drugAllergies.ForEach (
drugAllergy =>
{
var da = BuildPatientAllergyFreeformType ( drugAllergy );
allergies.Add ( da );
} );
return allergies;
}
public void Rename_GivenValidName_PatientRenamedEventWithCorrectInfoIsRaised()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
Patient patientArgumentInEvent = null;
DomainEvent.Register<PatientRenamedEvent> ( p => patientArgumentInEvent = p.Patient );
var agencyMock = new Mock<Agency>();
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var patient = new Patient(agencyMock.Object, name, new PatientProfileBuilder().Build());
var newName = new PersonNameBuilder()
.WithFirst("Fred")
.WithLast("Thomas");
// Exercise
patient.Rename(newName);
// Verify
Assert.IsTrue(ReferenceEquals(patient, patientArgumentInEvent) && patientArgumentInEvent.Name == newName);
}
}
private PatientType BuildPatientType( Patient patient )
{
if ( patient != null )
{
return new PatientType
{
ID = patient.Key.ToString (),
PatientName = new PersonNameType { Last = patient.Name.Last, First = patient.Name.First, Middle = patient.Name.Middle },
MedicalRecordNumber = patient.UniqueIdentifier,
Memo = string.Empty,
PatientAddress = PatientAddress ( patient ),
PatientCharacteristics = BuildPatientCharacteristics ( patient ),
PatientFreeformAllergy = BuildPatientFreeFormAllergies ( patient )
};
}
return BuildDummyPatient ();
}
public void Rename_GivenNullAgency_ThrowsArgumentException()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
Agency agency = null;
var name = new PersonNameBuilder()
.WithFirst("Albert")
.WithLast("Smith");
var patient = new Patient(agency, name, new PatientProfileBuilder().Build());
// Exercise
patient.Rename(null);
// Verify
}
}
private void LoadEntitiesFromDomain( long patientKey, long staffKey, long agencyKey, long locationKey )
{
Logger.Debug ( "LoadEntitiesFromDomain - Loading Entities" );
var patientCriteria =
DetachedCriteria.For<Patient> ( "p" ).Add ( Restrictions.Eq ( Projections.Property ( "p.Key" ), patientKey ) );
var staffCriteria = DetachedCriteria
.For<Staff> ( "s" )
.Add ( Restrictions.Eq ( Projections.Property ( "s.Key" ), staffKey ) );
var agencyCriteria =
DetachedCriteria.For<Agency> ( "a" ).Add ( Restrictions.Eq ( Projections.Property ( "a.Key" ), agencyKey ) );
var locationCriteria =
DetachedCriteria.For<Location> ( "l" ).Add ( Restrictions.Eq ( Projections.Property ( "l.Key" ), locationKey ) );
var multiCriteria =
_session.CreateMultiCriteria ()
.Add ( patientCriteria )
.Add ( staffCriteria )
.Add ( agencyCriteria )
.Add ( locationCriteria );
var criteriaList = multiCriteria.List ();
try
{
_patient = ( ( IList )criteriaList[0] )[0] as Patient;
}
catch ( ArgumentOutOfRangeException )
{
//// No patient with an Id of [_patientKey] was found.
_patient = null;
}
_staff = ( ( IList )criteriaList[1] )[0] as Staff;
_agency = ( ( IList )criteriaList[2] )[0] as Agency;
_location = ( ( IList )criteriaList[3] )[0] as Location;
}