/// <summary>
/// Translates the specified clinical payor coverage.
/// </summary>
/// <param name="clinicalPayorCoverage">The clinical payor coverage.</param>
/// <returns>A billing PayorCoverage.</returns>
public PayorCoverage Translate(PayorCoverageCache clinicalPayorCoverage)
{
if (clinicalPayorCoverage == null)
{
return(null);
}
var payor = _payorRepository.GetByKey(clinicalPayorCoverage.PayorCache.Key);
var clinicalPayorSubscriber = clinicalPayorCoverage.PayorSubscriberCache;
var payorSubscriberRelationshipType =
_lookupValueRepository.GetLookupByWellKnownName <PayorSubscriberRelationshipType> (
clinicalPayorSubscriber.PayorSubscriberRelationshipCacheType.WellKnownName);
var payorSubscriber = new PayorSubscriber(
clinicalPayorSubscriber.Address,
clinicalPayorSubscriber.BirthDate,
clinicalPayorSubscriber.AdministrativeGender,
clinicalPayorSubscriber.Name,
payorSubscriberRelationshipType);
var payorCoverageType =
_lookupValueRepository.GetLookupByWellKnownName <PayorCoverageType> (clinicalPayorCoverage.PayorCoverageCacheType.WellKnownName);
var billingPayorCoverage = new PayorCoverage(
payor, payorSubscriber, clinicalPayorCoverage.MemberNumber, clinicalPayorCoverage.EffectiveDateRange, payorCoverageType);
return(billingPayorCoverage);
}
/// <summary>
/// Creates the immunization.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>An Immunization.</returns>
public Immunization CreateImmunization(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.Immunization);
var immunization = new Immunization(visit, activityType);
_immunizationRepository.MakePersistent(immunization);
return(immunization);
}
/// <summary>
/// Creates the lab specimen.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A LabSpecimen.</returns>
public LabSpecimen CreateLabSpecimen(Visit visit)
{
var type = _lookupValueRepository.GetLookupByWellKnownName <VisitModule.ActivityType>(ActivityType.LabSpecimen);
var labSpecimen = new LabSpecimen(visit, type);
_labSpecimenRepository.MakePersistent(labSpecimen);
return(labSpecimen);
}
/// <summary>
/// Creates the vital sign.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>
/// A VitalSign.
/// </returns>
public VitalSign CreateVitalSign(Visit visit)
{
var type = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.VitalSign);
var vitalSign = new VitalSign(visit, type);
_vitalSignRepository.MakePersistent(vitalSign);
return(vitalSign);
}
/// <summary>
/// If the visit does not have a Phq9, then it returns a newly created Phq9,
/// else, it returns an existing one from the visit.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A Phq9.</returns>
public Phq9 CreatePhq9(Visit visit)
{
Check.IsNotNull(visit, "visit is required.");
Phq9 phq9;
var existingNidaDrugQuestionnaire = _phq9Repository.GetPhq9ByVisitKey(visit.Key);
if (existingNidaDrugQuestionnaire != null)
{
phq9 = existingNidaDrugQuestionnaire;
}
else
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.Phq9);
phq9 = new Phq9(visit, activityType);
_phq9Repository.MakePersistent(phq9);
DomainEvent.Raise(new Phq9CreatedEvent {
Phq9 = phq9
});
}
return(phq9);
}
/// <summary>
/// If the visit does not have a NidaDrugQuestionnaire, then it returns a newly created NidaDrugQuestionnaire,
/// else, it returns an existing one from the visit.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A NidaDrugQuestionnaire.</returns>
public NidaDrugQuestionnaire CreateNidaDrugQuestionnaire(Visit visit)
{
Check.IsNotNull(visit, "visit is required.");
NidaDrugQuestionnaire nidaDrugQuestionnaire;
var existingNidaDrugQuestionnaire = _nidaDrugQuestionnaireRepository.GetNidaDrugQuestionnaireInVisit(visit.Key);
if (existingNidaDrugQuestionnaire != null)
{
nidaDrugQuestionnaire = existingNidaDrugQuestionnaire;
}
else
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.NidaDrugQuestionnaire);
nidaDrugQuestionnaire = new NidaDrugQuestionnaire(visit, activityType);
_nidaDrugQuestionnaireRepository.MakePersistent(nidaDrugQuestionnaire);
DomainEvent.Raise(new NidaDrugQuestionnaireCreatedEvent {
NidaDrugQuestionnaire = nidaDrugQuestionnaire
});
}
return(nidaDrugQuestionnaire);
}
/// <summary>
/// If the visit does not have a Dast10, then it returns a newly created Dast10,
/// else, it returns an existing one from the visit.
/// </summary>
/// <param name="visit">A visit.</param>
/// <returns>A Dast10.</returns>
public Dast10 CreateDast10(Visit visit)
{
Check.IsNotNull(visit, "visit is required.");
Dast10 dast10;
var existingNidaDrugQuestionnaire = _dast10Repository.GetDast10ByVisitKey(visit.Key);
if (existingNidaDrugQuestionnaire != null)
{
dast10 = existingNidaDrugQuestionnaire;
}
else
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.Dast10);
dast10 = new Dast10(visit, activityType);
_dast10Repository.MakePersistent(dast10);
DomainEvent.Raise(new Dast10CreatedEvent {
Dast10 = dast10
});
}
return(dast10);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>A <see cref="Agatha.Common.Response"/></returns>
public override Response Handle(CreateNewClinicalCaseRequest request)
{
var patient = _patientRepository.GetByKey(request.PatientKey);
var location = _locationRepository.GetByKey(request.LocationKey);
var clinicalCaseStatus = _lookupValueRepository.GetLookupByWellKnownName <ClinicalCaseStatus> (
WellKnownNames.ClinicalCaseModule.ClinicalCaseStatus.CaseInitiation);
var entity = _clinicalCaseFactory.CreateClinicalCase(
patient, new ClinicalCaseProfileBuilder().WithInitialLocation(location));
entity.UpdateStatus(clinicalCaseStatus);
var response = CreateTypedResponse();
response.ClinicalCaseDto = new ClinicalCaseDto
{
Key = entity.Key,
ClinicalCaseProfile = new ClinicalCaseProfileDto
{
Key = entity.Key,
PatientKey = entity.Patient.Key,
PatientFullName = entity.Patient.Name.First + " " + entity.Patient.Name.Last,
InitialLocation = Mapper.Map <Location, LocationDisplayNameDto> (entity.ClinicalCaseProfile.InitialLocation),
ClinicalCaseNumber = entity.ClinicalCaseNumber
},
ClinicalCaseStatus = new ClinicalCaseStatusDto
{
ClinicalCaseStatus = Mapper.Map <ClinicalCaseStatus, LookupValueDto> (entity.ClinicalCaseStatus)
}
};
return(response);
}
/// <summary>
/// Synchronizes the service.
/// </summary>
/// <param name="encounter">The encounter.</param>
/// <param name="procedure">The procedure.</param>
/// <param name="diagnosis">The diagnosis.</param>
/// <returns>A service.</returns>
public Service SynchronizeService(Encounter encounter, Procedure procedure, CodedConcept diagnosis)
{
Check.IsNotNull(encounter, "Encounter is required.");
Check.IsNotNull(procedure, "Procedure is required.");
Check.IsNotNull(diagnosis, "Diagnosis is required.");
var medicalProcedure = _medicalProcedureTranslator.Translate(procedure);
var service = _serviceRepository.GetByTrackingNumber(procedure.Key);
var primaryIndicator = (procedure.ProcedureType != ProcedureType.Activity);
if (service == null)
{
service = _serviceFactory.CreateService(encounter, diagnosis, medicalProcedure, primaryIndicator, procedure.Key);
}
else
{
if (encounter.Key != service.Encounter.Key)
{
service.ReviseEncounter(encounter);
}
if (diagnosis != service.Diagnosis)
{
service.ReviseDiagnosis(diagnosis);
}
if (medicalProcedure != service.MedicalProcedure)
{
service.ReviseMedicalProcedure(medicalProcedure);
}
if (procedure.Key != service.TrackingNumber)
{
service.ReviseTrackingNumber(procedure.Key);
}
if (primaryIndicator != service.PrimaryIndicator)
{
service.RevisePrimaryIndicator(primaryIndicator);
}
if (procedure.BillingUnitCount != service.BillingUnitCount)
{
service.ReviseBillingUnitCount(procedure.BillingUnitCount);
}
}
//TODO: move them to ctor
var currency = _lookupValueRepository.GetLookupByWellKnownName <Currency>(WellKnownNames.CommonModule.Currency.USDollars);
service.ReviseChargeAmount(new Money(currency, 1));
var c = new UnitCount(1);
service.ReviseBillingUnitCount(c);
return(service);
}
/// <summary>
/// Creates the gain short screener.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A GainShortScreener.</returns>
public GainShortScreener CreateGainShortScreener(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.GainShortScreener);
var gainShortScreener = new GainShortScreener(visit, activityType);
_gainShortScreenerRepository.MakePersistent(gainShortScreener);
return(gainShortScreener);
}
/// <summary>
/// Creates the DensAsi interview.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A DensAsiInterview.</returns>
public DensAsiInterview CreateDensAsiInterview(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(WellKnownNames.VisitModule.ActivityType.DensAsiInterview);
var densAsiInterview = new DensAsiInterview(visit, activityType);
_densAsiInterviewRepository.MakePersistent(densAsiInterview);
return(densAsiInterview);
}
/// <summary>
/// Creates the radiology order.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A <see cref="T:Rem.Domain.Clinical.RadiologyModule.RadiologyOrder">RadiologyOrder</see>.</returns>
public RadiologyOrder CreateRadiologyOrder(Visit visit)
{
var type = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.RadiologyOrder);
var radiology = new RadiologyOrder(visit, type);
_radiologyOrderRepository.MakePersistent(radiology);
return(radiology);
}
/// <summary>
/// Creates the Gpra interview.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A GpraInterview.</returns>
public GpraInterview CreateGpraInterview(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(WellKnownNames.VisitModule.ActivityType.GpraInterview);
var gpraInterview = new GpraInterview(visit, activityType);
_gpraInterviewRepository.MakePersistent(gpraInterview);
return(gpraInterview);
}
/// <summary>
/// Creates the individual counseling.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>
/// An IndividualCounseling.
/// </returns>
public IndividualCounseling CreateIndividualCounseling(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.IndividualCounseling);
var individualCounseling = new IndividualCounseling(visit, activityType);
_individualCounselingRepository.MakePersistent(individualCounseling);
return(individualCounseling);
}
/// <summary>
/// Creates the Teds interview.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A TedsAdmissionInterview.</returns>
public TedsAdmissionInterview CreateTedsAdmissionInterview(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(WellKnownNames.VisitModule.ActivityType.TedsAdmissionInterview);
var TedsAdmissionInterview = new TedsAdmissionInterview(visit, activityType);
_tedsAdmissionInterviewRepository.MakePersistent(TedsAdmissionInterview);
return(TedsAdmissionInterview);
}
/// <summary>
/// Creates the brief intervention.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A BriefIntervention.</returns>
public BriefIntervention CreateBriefIntervention(Visit visit)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.BriefIntervention);
var briefIntervention = new BriefIntervention(visit, activityType);
_briefInterventionRepository.MakePersistent(briefIntervention);
return(briefIntervention);
}
private void ScheduleActivity(string activityWellKnownName)
{
if (_activitySchedulerService == null)
{
_activitySchedulerService = IoC.CurrentContainer.Resolve <IActivitySchedulerService>();
}
if (_lookupValueRepository == null)
{
_lookupValueRepository = IoC.CurrentContainer.Resolve <ILookupValueRepository>();
}
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(activityWellKnownName);
_activitySchedulerService.ScheduleActivity(Visit.Key, activityType);
}
private NidaDrugQuestionnaire ScheduleNidaDrugQuestionnaire()
{
if (_activitySchedulerService == null)
{
_activitySchedulerService = IoC.CurrentContainer.Resolve <IActivitySchedulerService> ();
}
if (_lookupValueRepository == null)
{
_lookupValueRepository = IoC.CurrentContainer.Resolve <ILookupValueRepository> ();
}
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.NidaDrugQuestionnaire);
return(( NidaDrugQuestionnaire )_activitySchedulerService.ScheduleActivity(Visit.Key, activityType));
}
private T MapLookupObject <T>(string wellKnownName)
where T : LookupBase
{
var lookupObject = _lookupValueRepository.GetLookupByWellKnownName(typeof(T), wellKnownName);
if (lookupObject == null)
{
throw new SystemException(
"LookupValue for type " + typeof(T).Name + " and well known name " + wellKnownName +
" cannot be found.");
}
var typedLookup = lookupObject as T;
return(typedLookup);
}
/// <summary>
/// Creates the audit.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>
/// An Audit.
/// </returns>
public Audit CreateAudit(Visit visit)
{
// TODO: This checks only the currently submitted session activities. Need to implement a solution that addresses multiple session concurrency issues.
var auditFirst = visit.Activities.FirstOrDefault(a => a.ActivityType.WellKnownName == WellKnownNames.VisitModule.ActivityType.Audit);
if (auditFirst != null)
{
return(auditFirst as Audit);
}
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(WellKnownNames.VisitModule.ActivityType.Audit);
var audit = new Audit(visit, activityType);
_auditRepository.MakePersistent(audit);
return(audit);
}
/// <summary>
/// Synchronizes the encounter with the clinical visit.
/// </summary>
/// <param name="patientAccount">The patient account.</param>
/// <param name="visit">The visit.</param>
/// <returns>
/// An <see cref="Encounter"/> instance.
/// </returns>
public Encounter SynchronizeEncounter(PatientAccount patientAccount, Visit visit)
{
Check.IsNotNull(patientAccount, "Patient account is required.");
Check.IsNotNull(visit, "Visit is required.");
var serviceProvider = visit.Staff;
var placeOfService = visit.ServiceLocation;
var encounter = _encounterRepository.GetByTrackingNumber(visit.Key);
if (encounter == null)
{
encounter = _encounterFactory.CreateEncounter(
patientAccount,
placeOfService,
serviceProvider,
visit.Key,
visit.CheckedInDateTime ?? DateTime.Now);
}
else
{
if (encounter.PatientAccount.Key != patientAccount.Key)
{
encounter.RevisePatientAccount(patientAccount);
}
if (encounter.ServiceLocation.Key != placeOfService.Key)
{
encounter.RevisePlaceOfService(placeOfService);
}
if (encounter.ServiceProviderStaff.Key != serviceProvider.Key)
{
encounter.ReviseServiceProvider(serviceProvider);
}
}
//TODO: move them to ctor
var currency = _lookupValueRepository.GetLookupByWellKnownName <Currency>(WellKnownNames.CommonModule.Currency.USDollars);
encounter.ReviseChargeAmount(new Money(currency, 2));
return(encounter);
}
/// <summary>
/// Translates the specified patient phone.
/// </summary>
/// <param name="patientPhone">The patient phone.</param>
/// <returns>A PatientAccountPhone.</returns>
public PatientAccountPhone Translate(PatientPhone patientPhone)
{
if (patientPhone == null)
{
return(null);
}
var patientAccountPhoneTypeWellKnownName = WellKnownNames.PatientAccountModule.PatientAccountPhoneType.Home;
if (patientPhone.PatientPhoneType.WellKnownName == WellKnownNames.PatientModule.PatientPhoneType.Cell)
{
patientAccountPhoneTypeWellKnownName = WellKnownNames.PatientAccountModule.PatientAccountPhoneType.Cell;
}
var patientAccountPhoneType = _lookupValueRepository.GetLookupByWellKnownName <PatientAccountPhoneType>(patientAccountPhoneTypeWellKnownName);
var patientAccountPhone = new PatientAccountPhone(patientAccountPhoneType, new Phone(patientPhone.PhoneNumber, patientPhone.PhoneExtensionNumber));
return(patientAccountPhone);
}
/// <summary>
/// If the visit does not have a SocialHistory, then it returns a newly created SocialHistory,
/// else, it returns an existing one from the visit.
/// </summary>
/// <param name="visit">The visit.</param>
/// <returns>A SocialHistory.</returns>
public SocialHistory CreateSocialHistory(Visit visit)
{
Check.IsNotNull(visit, "visit is required.");
//NOTE : There can be only one 'Social History' per visit.
SocialHistory socialHistory;
var existingSocialHistory = _socialHistoryRepository.GetSocialHistoryInVisit(visit.Key);
if (existingSocialHistory != null)
{
socialHistory = existingSocialHistory;
}
else
{
var type = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.SocialHistory);
socialHistory = new SocialHistory(visit, type);
_socialHistoryRepository.MakePersistent(socialHistory);
}
return(socialHistory);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>A <see cref="Agatha.Common.Response"/></returns>
public override Response Handle(LogPatientEventAccessRequest request)
{
var logEntryDto = request.LogEntryDto;
var patient = _patientRepository.GetByKey(logEntryDto.PatientKey);
if (patient == null)
{
throw new ArgumentException("Could not find a patient with Key =" + logEntryDto.PatientKey);
}
var eventType = _lookupValueRepository.GetLookupByWellKnownName(
typeof(PatientAccessEventType), WellKnownNames.PatientModule.PatientAccessEventType.ReadEvent) as PatientAccessEventType;
var formattedNote = string.Format(logEntryDto.Note, patient.Name.Complete);
var eventAccessEntry = _patientAccessEventFactory.CreatePatientAccessEvent(patient, eventType, logEntryDto.AuditedContextDescription, formattedNote);
_auditPatientReadAccessService.AuditPatientReadAccess(eventAccessEntry);
var response = CreateTypedResponse();
return(response);
}
/// <summary>
/// If the visit does not have a AuditC, then it returns a newly created AuditC,
/// else, it returns an existing one from the visit.
/// </summary>
/// <param name="visit">A visit.</param>
/// <returns>An AuditC.</returns>
public AuditC CreateAuditC(Visit visit)
{
AuditC auditC;
var existingNidaDrugQuestionnaire = _auditCRepository.GetAuditCByVisitKey(visit.Key);
if (existingNidaDrugQuestionnaire != null)
{
auditC = existingNidaDrugQuestionnaire;
}
else
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.AuditC);
auditC = new AuditC(visit, activityType);
_auditCRepository.MakePersistent(auditC);
DomainEvent.Raise(new AuditCCreatedEvent {
AuditC = auditC
});
}
return(auditC);
}