public ModalityPerformedProcedureStepDetail CreateModalityPerformedProcedureStepDetail(ModalityPerformedProcedureStep mpps, IPersistenceContext context)
{
var assembler = new ModalityProcedureStepAssembler();
// include the details of each MPS in the mpps summary
var mpsDetails = CollectionUtils.Map(mpps.Activities,
(ProcedureStep mps) => assembler.CreateProcedureStepSummary(mps.As<ModalityProcedureStep>(), context));
var dicomSeriesAssembler = new DicomSeriesAssembler();
var dicomSeries = dicomSeriesAssembler.GetDicomSeriesDetails(mpps.DicomSeries);
StaffSummary mppsPerformer = null;
var performer = mpps.Performer as ProcedureStepPerformer;
if (performer != null)
{
var staffAssembler = new StaffAssembler();
mppsPerformer = staffAssembler.CreateStaffSummary(performer.Staff, context);
}
return new ModalityPerformedProcedureStepDetail(
mpps.GetRef(),
EnumUtils.GetEnumValueInfo(mpps.State, context),
mpps.StartTime,
mpps.EndTime,
mppsPerformer,
mpsDetails,
dicomSeries,
ExtendedPropertyUtils.Copy(mpps.ExtendedProperties));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var response = (LoadPatientProfileForEditResponse)recorderContext.Response;
var patientProfile = persistenceContext.Load<PatientProfile>(response.PatientProfileRef, EntityLoadFlags.None);
return new OperationData(Operations.OpenForUpdate, patientProfile);
}
public ModelloContabileService(IRipartizioneSpeseService ripartizioneSpeseService, IUtenzaService utenzaService, IPersistenceContext persistenceContext, IDaoFactory daoFactory)
{
_ripartizioneSpeseService = ripartizioneSpeseService;
_utenzaService = utenzaService;
_persistenceContext = persistenceContext;
_daoFactory = daoFactory;
}
/// <summary>
/// Import user from CSV format.
/// </summary>
/// <param name="rows">
/// Each string in the list must contain 25 CSV fields, as follows:
/// 0 - UserName
/// 1 - StaffType
/// 2 - Id
/// 3 - FamilyName
/// 4 - GivenName
/// 5 - MiddleName
/// 6 - Prefix
/// 7 - Suffix
/// 8 - Degree
/// </param>
/// <param name="context"></param>
public override void Import(List<string> rows, IUpdateContext context)
{
_context = context;
List<User> importedUsers = new List<User>();
foreach (string row in rows)
{
string[] fields = ParseCsv(row, _numFields);
string userName = fields[0];
string staffId = fields[2];
string staffFamilyName = fields[3];
string staffGivenName = fields[4];
User user = GetUser(userName, importedUsers);
if (user == null)
{
UserInfo userInfo =
new UserInfo(userName, string.Format("{0} {1}", staffFamilyName, staffGivenName), null, null, null);
user = User.CreateNewUser(userInfo, _settings.DefaultTemporaryPassword);
_context.Lock(user, DirtyState.New);
importedUsers.Add(user);
}
}
}
public ReportDetail CreateReportDetail(Report report, bool includeCancelledParts, IPersistenceContext context)
{
ReportDetail detail = new ReportDetail();
detail.ReportRef = report.GetRef();
detail.ReportStatus = EnumUtils.GetEnumValueInfo(report.Status, context);
ProcedureAssembler rpAssembler = new ProcedureAssembler();
detail.Procedures = CollectionUtils.Map<Procedure, ProcedureDetail>(report.Procedures,
delegate(Procedure p)
{
return rpAssembler.CreateProcedureDetail(
p,
delegate(ProcedureStep ps) { return ps.Is<ReportingProcedureStep>(); }, // only Reporting steps are relevant
false, // exclude protocols
context);
});
List<ReportPartDetail> parts = CollectionUtils.Map<ReportPart, ReportPartDetail>(report.Parts,
delegate(ReportPart part) { return CreateReportPartDetail(part, context); });
detail.Parts = includeCancelledParts ? parts :
CollectionUtils.Select(parts,
delegate(ReportPartDetail rpp)
{
return rpp.Status.Code.Equals(ReportPartStatus.X.ToString()) == false;
});
return detail;
}
public ReportSummary CreateReportSummary(Procedure rp, Report report, IPersistenceContext context)
{
ReportSummary summary = new ReportSummary();
ProcedureAssembler rpAssembler = new ProcedureAssembler();
if (report != null)
{
summary.ReportRef = report.GetRef();
summary.ReportStatus = EnumUtils.GetEnumValueInfo(report.Status, context);
// use all procedures attached to report
summary.Procedures = CollectionUtils.Map<Procedure, ProcedureSummary>(report.Procedures,
delegate(Procedure p) { return rpAssembler.CreateProcedureSummary(p, context); });
}
else
{
// use supplied procedure
summary.Procedures = CollectionUtils.Map<Procedure, ProcedureSummary>(new Procedure[] { rp },
delegate(Procedure p) { return rpAssembler.CreateProcedureSummary(p, context); });
}
Order order = rp.Order;
summary.VisitNumber = new VisitAssembler().CreateVisitNumberDetail(order.Visit.VisitNumber);
summary.AccessionNumber = order.AccessionNumber;
summary.DiagnosticServiceName = order.DiagnosticService.Name;
return summary;
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (WorklistItemTextQueryRequest) recorderContext.Request;
return request.UseAdvancedSearch ?
new SearchOperationData(Operations.WorklistSearch, request.SearchFields)
: new SearchOperationData(Operations.WorklistSearch, request.TextQuery);
}
/// <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
}
/// <summary>
/// Gets a list of Web Study Move or AutoRoute WorkQueue entries
/// that are in progress for this device.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public List<WorkQueue> GetAllCurrentMoveEntries(IPersistenceContext context)
{
IQueryCurrentStudyMove broker = context.GetBroker<IQueryCurrentStudyMove>();
QueryCurrentStudyMoveParameters criteria = new QueryCurrentStudyMoveParameters();
criteria.DeviceKey = Key;
return new List<WorkQueue>(broker.Find(criteria));
}
public override AlertNotification Test(Order order, IPersistenceContext context)
{
var reasons = new List<string>();
if (order.Visit == null)
{
// This should never happen in production because an order must have a visit
reasons.Add("This order is missing a visit");
}
else
{
// Check Visit status
if (order.Visit.Status != VisitStatus.AA)
reasons.Add("Visit Status is not active");
// Check Visit date
if (order.Visit.AdmitTime == null)
{
// This should never happen in production since visit admit date should always be created from HIS
reasons.Add("Visit date is missing");
}
else if (order.ScheduledStartTime != null)
{
if (order.Visit.AdmitTime.Value.Date > order.ScheduledStartTime.Value.Date)
reasons.Add("Visit date is in the future");
else if (order.Visit.AdmitTime.Value.Date < order.ScheduledStartTime.Value.Date)
reasons.Add("Visit date is in the past");
}
}
if (reasons.Count > 0)
return new AlertNotification(this.Id, reasons);
return null;
}
public void Execute(ReportPart reportPart, IPersistenceContext context)
{
if (_enabled == false)
return;
LogicalHL7Event.ReportPublished.EnqueueEvents(reportPart.Report);
}
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 ExternalPractitionerDetail CreateExternalPractitionerDetail(ExternalPractitioner prac, IPersistenceContext context)
{
var assembler = new PersonNameAssembler();
var sortedContactPoints = CollectionUtils.Sort(prac.ContactPoints, (x, y) =>
{
if (ReferenceEquals(x, y)) return 0;
if (x.IsDefaultContactPoint) return -1;
if (y.IsDefaultContactPoint) return 1;
return string.Compare(x.Name, y.Name);
});
var contactPointDetails = CollectionUtils.Map(
sortedContactPoints,
(ExternalPractitionerContactPoint cp) => CreateExternalPractitionerContactPointDetail(cp, context));
var detail = new ExternalPractitionerDetail(
prac.GetRef(),
assembler.CreatePersonNameDetail(prac.Name),
prac.LicenseNumber,
prac.BillingNumber,
prac.IsVerified,
prac.LastVerifiedTime,
prac.LastEditedTime,
contactPointDetails,
ExtendedPropertyUtils.Copy(prac.ExtendedProperties),
CreateExternalPractitionerSummary(prac.GetUltimateMergeDestination(), context),
prac.IsMerged,
prac.Deactivated);
return detail;
}
public void UpdateExternalPractitioner(ExternalPractitionerDetail detail, ExternalPractitioner prac, IPersistenceContext context)
{
// validate that only one contact point is specified as default
var defaultPoints = CollectionUtils.Select(detail.ContactPoints, cp => cp.IsDefaultContactPoint);
if(defaultPoints.Count > 1)
throw new RequestValidationException(SR.ExceptionOneDefaultContactPoint);
var assembler = new PersonNameAssembler();
assembler.UpdatePersonName(detail.Name, prac.Name);
prac.LicenseNumber = detail.LicenseNumber;
prac.BillingNumber = detail.BillingNumber;
prac.MarkDeactivated(detail.Deactivated);
// update contact points collection
var syncHelper = new CollectionSynchronizeHelper<ExternalPractitionerContactPoint, ExternalPractitionerContactPointDetail>(
delegate (ExternalPractitionerContactPoint cp, ExternalPractitionerContactPointDetail cpDetail)
{
// ignore version in this comparison - deal with this issue in the update delegate
return cp.GetRef().Equals(cpDetail.ContactPointRef, true);
},
delegate (ExternalPractitionerContactPointDetail cpDetail, ICollection<ExternalPractitionerContactPoint> cps)
{
// create a new contact point
var cp = new ExternalPractitionerContactPoint(prac);
UpdateExternalPractitionerContactPoint(cpDetail, cp, context);
cps.Add(cp);
},
(cp, cpDetail, cps) => UpdateExternalPractitionerContactPoint(cpDetail, cp, context),
(cp, cps) => cps.Remove(cp));
syncHelper.Synchronize(prac.ContactPoints, detail.ContactPoints);
ExtendedPropertyUtils.Update(prac.ExtendedProperties, detail.ExtendedProperties);
}
public void UpdateHealthcard(HealthcardNumber hc, HealthcardDetail detail, IPersistenceContext context)
{
hc.Id = detail.Id;
hc.AssigningAuthority = EnumUtils.GetEnumValue<InsuranceAuthorityEnum>(detail.AssigningAuthority, context);
hc.VersionCode = detail.VersionCode;
hc.ExpiryDate = detail.ExpiryDate;
}
public void UpdateProcedureType(ProcedureType procType, ProcedureTypeDetail detail, IPersistenceContext context)
{
procType.Id = detail.Id;
procType.Name = detail.Name;
procType.BaseType = detail.CustomProcedurePlan && detail.BaseType != null
? context.Load<ProcedureType>(detail.BaseType.ProcedureTypeRef, EntityLoadFlags.Proxy)
: null;
procType.DefaultDuration = detail.DefaultDuration;
procType.Deactivated = detail.Deactivated;
try
{
if(detail.CustomProcedurePlan)
{
procType.Plan = new ProcedurePlan(detail.PlanXml);
}
else
{
var modality = context.Load<Modality>(detail.DefaultModality.ModalityRef);
procType.Plan = ProcedurePlan.CreateDefaultPlan(detail.Name, modality);
}
}
catch (XmlException e)
{
throw new RequestValidationException(string.Format("Procedure plan XML is invalid: {0}", e.Message));
}
}
public VisitSummary CreateVisitSummary(Visit visit, IPersistenceContext context)
{
var patientProfileAssembler = new PatientProfileAssembler();
var summary = new VisitSummary
{
VisitRef = visit.GetRef(),
Patient = patientProfileAssembler.CreatePatientProfileSummary(visit.PatientProfile, context),
VisitNumber = CreateVisitNumberDetail(visit.VisitNumber),
AdmissionType = EnumUtils.GetEnumValueInfo(visit.AdmissionType),
PatientClass = EnumUtils.GetEnumValueInfo(visit.PatientClass),
PatientType = EnumUtils.GetEnumValueInfo(visit.PatientType),
Status = EnumUtils.GetEnumValueInfo(visit.Status, context),
AdmitTime = visit.AdmitTime,
DischargeTime = visit.DischargeTime
};
var facilityAssembler = new FacilityAssembler();
summary.Facility = visit.Facility == null ? null : facilityAssembler.CreateFacilitySummary(visit.Facility);
var locationAssembler = new LocationAssembler();
summary.CurrentLocation = visit.CurrentLocation == null ? null : locationAssembler.CreateLocationSummary(visit.CurrentLocation);
summary.CurrentRoom = visit.CurrentRoom;
summary.CurrentBed = visit.CurrentBed;
return summary;
}
public ImportazioneDocumentiBolletteService(IUtenzaCsvRepository utenzaCsvRepository, IUtenzaDocumentoService utenzaDocumentoService, IPersistenceContext persistenceContext, IFileSystem fileSystem)
{
_utenzaDocumentoService = utenzaDocumentoService;
_fileSystem = fileSystem;
_utenzaCsvRepository = utenzaCsvRepository;
_persistenceContext = persistenceContext;
}
private static void CreateSysAdminUser(AuthorityGroup adminGroup, SetupCommandLine cmdLine, IPersistenceContext context, TextWriter log)
{
try
{
// create the sa user, if doesn't already exist
IUserBroker userBroker = context.GetBroker<IUserBroker>();
UserSearchCriteria where = new UserSearchCriteria();
where.UserName.EqualTo(cmdLine.SysAdminUserName);
userBroker.FindOne(where);
log.WriteLine(string.Format("User '{0}' already exists.", cmdLine.SysAdminUserName));
}
catch (EntityNotFoundException)
{
HashedSet<AuthorityGroup> groups = new HashedSet<AuthorityGroup>
{
adminGroup
};
// create sa user using initial password, set to expire never
User saUser = User.CreateNewUser(
new UserInfo(cmdLine.SysAdminUserName, cmdLine.SysAdminDisplayName, null, null, null),
Password.CreatePassword(cmdLine.SysAdminInitialPassword, null),
groups);
context.Lock(saUser, DirtyState.New);
}
}
/// <summary>
/// Load a list of preferred SOP Classes and Transfer Syntaxes for a Device.
/// </summary>
/// <param name="read">A read context to read from the database.</param>
public void LoadPreferredSyntaxes(IPersistenceContext read)
{
var select = read.GetBroker<IDevicePreferredTransferSyntaxEntityBroker>();
// Setup the select parameters.
var criteria = new DevicePreferredTransferSyntaxSelectCriteria();
criteria.DeviceKey.EqualTo(_remoteDevice.GetKey());
IList<DevicePreferredTransferSyntax> list = select.Find(criteria);
// Translate the list returned into the database into a list that is supported by the Storage SCU Component
var sopList = new List<SupportedSop>();
foreach (DevicePreferredTransferSyntax preferred in list)
{
var sop = new SupportedSop
{
SopClass = SopClass.GetSopClass(preferred.GetServerSopClass().SopClassUid)
};
sop.AddSyntax(TransferSyntax.GetTransferSyntax(preferred.GetServerTransferSyntax().Uid));
sopList.Add(sop);
}
SetPreferredSyntaxList(sopList);
}
public ReportingWorklistItemSummary CreateWorklistItemSummary(ReportingWorklistItem domainItem, IPersistenceContext context)
{
PersonNameAssembler assembler = new PersonNameAssembler();
return new ReportingWorklistItemSummary(
domainItem.ProcedureStepRef,
domainItem.ProcedureRef,
domainItem.OrderRef,
domainItem.PatientRef,
domainItem.PatientProfileRef,
domainItem.ReportRef,
new MrnAssembler().CreateMrnDetail(domainItem.Mrn),
assembler.CreatePersonNameDetail(domainItem.PatientName),
domainItem.AccessionNumber,
EnumUtils.GetEnumValueInfo(domainItem.OrderPriority, context),
EnumUtils.GetEnumValueInfo(domainItem.PatientClass),
domainItem.DiagnosticServiceName,
domainItem.ProcedureName,
domainItem.ProcedurePortable,
domainItem.HasErrors,
EnumUtils.GetEnumValueInfo(domainItem.ProcedureLaterality, context),
domainItem.ProcedureStepName,
domainItem.Time,
domainItem.ActivityStatus.HasValue ? EnumUtils.GetEnumValueInfo(domainItem.ActivityStatus.Value, context) : null,
domainItem.ReportPartIndex
);
}
/// <summary>
/// Load the values for the sequence <see cref="DicomTags.RequestAttributesSequence"/>
/// into a response message for a specific series.
/// </summary>
/// <param name="read">The connection to use to read the values.</param>
/// <param name="response">The message to add the values into.</param>
/// <param name="row">The <see cref="Series"/> entity to load the related <see cref="RequestAttributes"/> entity for.</param>
private static void LoadRequestAttributes(IPersistenceContext read, DicomMessageBase response, Series row)
{
var select = read.GetBroker<IRequestAttributesEntityBroker>();
var criteria = new RequestAttributesSelectCriteria();
criteria.SeriesKey.EqualTo(row.GetKey());
IList<RequestAttributes> list = select.Find(criteria);
if (list.Count == 0)
{
response.DataSet[DicomTags.RequestAttributesSequence].SetNullValue();
return;
}
foreach (RequestAttributes request in list)
{
var item = new DicomSequenceItem();
item[DicomTags.ScheduledProcedureStepId].SetStringValue(request.ScheduledProcedureStepId);
item[DicomTags.RequestedProcedureId].SetStringValue(request.RequestedProcedureId);
response.DataSet[DicomTags.RequestAttributesSequence].AddSequenceItem(item);
}
}
public ProtocolDetail CreateProtocolDetail(Protocol protocol, IPersistenceContext context)
{
var detail = new ProtocolDetail();
var staffAssembler = new StaffAssembler();
detail.ProtocolRef = protocol.GetRef();
detail.Author = protocol.Author != null ? staffAssembler.CreateStaffSummary(protocol.Author, context) : null;
detail.Supervisor = protocol.Supervisor != null ? staffAssembler.CreateStaffSummary(protocol.Supervisor, context) : null;
detail.Status = EnumUtils.GetEnumValueInfo(protocol.Status, context);
detail.Urgency = EnumUtils.GetEnumValueInfo(protocol.Urgency);
detail.RejectReason = EnumUtils.GetEnumValueInfo(protocol.RejectReason);
detail.Codes = protocol.Codes == null
? new List<ProtocolCodeSummary>()
: CollectionUtils.Map<ProtocolCode, ProtocolCodeSummary>(protocol.Codes, CreateProtocolCodeSummary);
var procedureAssembler = new ProcedureAssembler();
detail.Procedures = protocol.Procedures == null
? new List<ProcedureDetail>()
: CollectionUtils.Map<Procedure, ProcedureDetail>(
protocol.Procedures,
procedure => procedureAssembler.CreateProcedureDetail(procedure, delegate { return false; }, false, context));
return detail;
}
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;
}
public override AlertNotification Test(Patient patient, IPersistenceContext context)
{
if (patient.Allergies.Count == 0)
return null;
var reasons = CollectionUtils.Map<Allergy, string>(patient.Allergies, allergy => allergy.AllergenDescription);
return new AlertNotification(this.Id, reasons);
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
if (recorderContext.Request is DiscontinueModalityProcedureStepsRequest)
return Capture((DiscontinueModalityProcedureStepsRequest) recorderContext.Request, persistenceContext);
if (recorderContext.Request is DiscontinueModalityPerformedProcedureStepRequest)
return Capture((DiscontinueModalityPerformedProcedureStepRequest)recorderContext.Request, persistenceContext);
throw new InvalidOperationException("Cannot audit this request");
}
protected override bool ShouldCapture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (SaveReportRequest)recorderContext.Request;
var rps = persistenceContext.Load<ReportingProcedureStep>(request.ReportingStepRef, EntityLoadFlags.None);
// only relevant for the main report, not for addendums (i.e. we are still in P status)
return rps.ReportPart.Report.Status == ReportStatus.P && base.ShouldCapture(recorderContext, persistenceContext);
}
public VisitListItem CreateVisitListItem(Visit visit, IPersistenceContext context)
{
var data = new VisitListItem();
UpdateListItem(data, visit, context);
return data;
}
public void UpdateFacility(FacilityDetail detail, Facility facility, IPersistenceContext context)
{
facility.Code = detail.Code;
facility.Name = detail.Name;
facility.Description = detail.Description;
facility.InformationAuthority = EnumUtils.GetEnumValue<InformationAuthorityEnum>(detail.InformationAuthority, context);
facility.Deactivated = detail.Deactivated;
}
private static OperationData Capture(DiscontinueModalityProcedureStepsRequest request, IPersistenceContext persistenceContext)
{
var procedures = request.ModalityProcedureSteps.Select(r => persistenceContext.Load<ModalityProcedureStep>(r, EntityLoadFlags.None).Procedure).ToList();
var order = procedures.First().Order;
var patientProfile = procedures.First().PatientProfile;
return new OperationData(Operations.Discontinue, patientProfile, order, procedures);
}
private PatientNoteCategory LoadOrCreatePatientNoteCategory(string name, NoteSeverity severity, IPersistenceContext context)
{
PatientNoteCategory nc;
try
{
// see if already exists in db
PatientNoteCategorySearchCriteria where = new PatientNoteCategorySearchCriteria();
where.Name.EqualTo(name);
nc = context.GetBroker <IPatientNoteCategoryBroker>().FindOne(where);
}
catch (EntityNotFoundException)
{
// create it
nc = new PatientNoteCategory(name, null, severity);
context.Lock(nc, DirtyState.New);
}
return(nc);
}
public void PreCommit(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContent)
{
}
private static Facility LoadOrCreateFacility(string code, string name, string description, InformationAuthorityEnum ia, IPersistenceContext context)
{
Facility pt;
try
{
// see if already exists in db
var where = new FacilitySearchCriteria();
where.Code.EqualTo(code);
pt = context.GetBroker <IFacilityBroker>().FindOne(where);
}
catch (EntityNotFoundException)
{
// create it
pt = new Facility(code, name, description, ia);
context.Lock(pt, DirtyState.New);
}
return(pt);
}
/// <summary>
/// Given that there is no pre-existing proxy.
/// Check if the entity is already loaded. If it is, return the entity,
/// otherwise create and return a proxy.
/// </summary>
private object CreateProxyIfNecessary(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options, IPersistenceContext persistenceContext)
{
object existing = persistenceContext.GetEntity(keyToLoad);
if (existing != null)
{
// return existing object or initialized proxy (unless deleted)
log.Debug("entity found in session cache");
if (options.IsCheckDeleted)
{
EntityEntry entry = persistenceContext.GetEntry(existing);
Status status = entry.Status;
if (status == Status.Deleted || status == Status.Gone)
{
return(null);
}
}
return(existing);
}
else
{
log.Debug("creating new proxy for entity");
// return new uninitialized proxy
object proxy = persister.CreateProxy(@event.EntityId, @event.Session);
persistenceContext.BatchFetchQueue.AddBatchLoadableEntityKey(keyToLoad);
persistenceContext.AddProxy(keyToLoad, (INHibernateProxy)proxy);
((INHibernateProxy)proxy)
.HibernateLazyInitializer
.ReadOnly = @event.Session.DefaultReadOnly || !persister.IsMutable;
return(proxy);
}
}
protected override bool ShouldCapture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (UnmergeOrderRequest)recorderContext.Request;
return(!request.DryRun);
}
/// <summary>
/// Creates order detail document including only specified parts.
/// </summary>
public OrderDetail CreateOrderDetail(Order order, CreateOrderDetailOptions options, IPersistenceContext context)
{
var orderDetail = new OrderDetail();
var practitionerAssembler = new ExternalPractitionerAssembler();
var facilityAssembler = new FacilityAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var procedureAssembler = new ProcedureAssembler();
var staffAssembler = new StaffAssembler();
orderDetail.OrderRef = order.GetRef();
orderDetail.PatientRef = order.Patient.GetRef();
if (options.IncludeVisit)
{
var visitAssembler = new VisitAssembler();
orderDetail.Visit = visitAssembler.CreateVisitDetail(order.Visit, context);
}
orderDetail.PlacerNumber = order.PlacerNumber;
orderDetail.AccessionNumber = order.AccessionNumber;
orderDetail.DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService);
orderDetail.EnteredTime = order.EnteredTime;
orderDetail.EnteredBy = order.EnteredBy == null ? null :
staffAssembler.CreateStaffSummary(order.EnteredBy, context);
orderDetail.EnteredComment = order.EnteredComment;
orderDetail.SchedulingRequestTime = order.SchedulingRequestTime;
orderDetail.OrderingPractitioner = practitionerAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context);
orderDetail.OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility);
orderDetail.ReasonForStudy = order.ReasonForStudy;
orderDetail.OrderPriority = EnumUtils.GetEnumValueInfo(order.Priority, context);
if (order.CancelInfo != null)
{
orderDetail.CancelReason = order.CancelInfo.Reason == null ? null : EnumUtils.GetEnumValueInfo(order.CancelInfo.Reason);
orderDetail.CancelledBy = order.CancelInfo.CancelledBy == null ? null :
staffAssembler.CreateStaffSummary(order.CancelInfo.CancelledBy, context);
orderDetail.CancelComment = order.CancelInfo.Comment;
}
if (options.IncludeProcedures)
{
orderDetail.Procedures = CollectionUtils.Map(order.Procedures,
(Procedure p) => procedureAssembler.CreateProcedureDetail(p, context));
}
if (options.IncludeNotes)
{
var orderNoteAssembler = new OrderNoteAssembler();
var orderNotes = new List <OrderNote>(OrderNote.GetNotesForOrder(order, options.NoteCategoriesFilter, options.IncludeVirtualNotes));
// sort notes by post-time (guaranteed non-null because only "posted" notes are in this collection)
orderNotes.Sort((x, y) => x.PostTime.Value.CompareTo(y.PostTime.Value));
// Put most recent notes first
orderNotes.Reverse();
orderDetail.Notes = CollectionUtils.Map <OrderNote, OrderNoteSummary>(
orderNotes,
note => orderNoteAssembler.CreateOrderNoteSummary(note, context));
}
if (options.IncludeAttachments)
{
var orderAttachmentAssembler = new OrderAttachmentAssembler();
var attachments = new List <OrderAttachment>(order.Attachments);
orderDetail.Attachments = CollectionUtils.Map <OrderAttachment, AttachmentSummary>(
attachments,
a => orderAttachmentAssembler.CreateOrderAttachmentSummary(a, context));
}
if (options.IncludeResultRecipients)
{
var resultRecipientAssembler = new ResultRecipientAssembler();
var resultRecipients = new List <ResultRecipient>(order.ResultRecipients);
orderDetail.ResultRecipients = CollectionUtils.Map <ResultRecipient, ResultRecipientDetail>(
resultRecipients,
r => resultRecipientAssembler.CreateResultRecipientDetail(r, context));
}
if (options.IncludeExtendedProperties)
{
orderDetail.ExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties);
}
return(orderDetail);
}
public UnitOfWorkExecution(IPersistenceContext persistenceContext, UnitOfWorkInfo info)
{
this.persistenceContext = persistenceContext;
this.info = info;
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var response = (LoadPatientProfileForEditResponse)recorderContext.Response;
var patientProfile = persistenceContext.Load <PatientProfile>(response.PatientProfileRef, EntityLoadFlags.None);
return(new OperationData(Operations.OpenForUpdate, patientProfile));
}
public virtual void OnDelete(DeleteEvent @event, ISet <object> transientEntities)
{
IEventSource source = @event.Session;
IPersistenceContext persistenceContext = source.PersistenceContext;
object entity = persistenceContext.UnproxyAndReassociate(@event.Entity);
EntityEntry entityEntry = persistenceContext.GetEntry(entity);
IEntityPersister persister;
object id;
object version;
if (entityEntry == null)
{
log.Debug("entity was not persistent in delete processing");
persister = source.GetEntityPersister(@event.EntityName, entity);
if (ForeignKeys.IsTransientSlow(persister.EntityName, entity, source))
{
DeleteTransientEntity(source, entity, @event.CascadeDeleteEnabled, persister, transientEntities);
// EARLY EXIT!!!
return;
}
else
{
PerformDetachedEntityDeletionCheck(@event);
}
id = persister.GetIdentifier(entity);
if (id == null)
{
throw new TransientObjectException("the detached instance passed to delete() had a null identifier");
}
EntityKey key = source.GenerateEntityKey(id, persister);
persistenceContext.CheckUniqueness(key, entity);
new OnUpdateVisitor(source, id, entity).Process(entity, persister);
version = persister.GetVersion(entity);
entityEntry = persistenceContext.AddEntity(
entity,
persister.IsMutable ? Status.Loaded : Status.ReadOnly,
persister.GetPropertyValues(entity),
key,
version,
LockMode.None,
true,
persister,
false,
false);
}
else
{
log.Debug("deleting a persistent instance");
if (entityEntry.Status == Status.Deleted || entityEntry.Status == Status.Gone)
{
log.Debug("object was already deleted");
return;
}
persister = entityEntry.Persister;
id = entityEntry.Id;
version = entityEntry.Version;
}
if (InvokeDeleteLifecycle(source, entity, persister))
{
return;
}
DeleteEntity(source, entity, entityEntry, @event.CascadeDeleteEnabled, persister, transientEntities);
if (source.Factory.Settings.IsIdentifierRollbackEnabled)
{
persister.ResetIdentifier(entity, id, version);
}
}
public Repository(IPersistenceContext persistenceContext, DataContext dataContext)
{
_dataContext = dataContext;
_persistenceContext = persistenceContext;
entities = dataContext.Set <TModel>();
}
private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event)
{
object optionalObject = @event.InstanceToLoad;
IEventSource session = @event.Session;
ISessionFactoryImplementor factory = session.Factory;
if (log.IsDebugEnabled())
{
log.Debug("assembling entity from second-level cache: {0}", MessageHelper.InfoString(persister, id, factory));
}
IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass);
object result = optionalObject ?? session.Instantiate(subclassPersister, id);
// make it circular-reference safe
EntityKey entityKey = session.GenerateEntityKey(id, subclassPersister);
TwoPhaseLoad.AddUninitializedCachedEntity(entityKey, result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session);
IType[] types = subclassPersister.PropertyTypes;
object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session); // intializes result by side-effect
TypeHelper.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session);
object version = Versioning.GetVersion(values, subclassPersister);
if (log.IsDebugEnabled())
{
log.Debug("Cached Version: {0}", version);
}
IPersistenceContext persistenceContext = session.PersistenceContext;
bool isReadOnly = session.DefaultReadOnly;
if (persister.IsMutable)
{
object proxy = persistenceContext.GetProxy(entityKey);
if (proxy != null)
{
// this is already a proxy for this impl
// only set the status to read-only if the proxy is read-only
isReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly;
}
}
else
{
isReadOnly = true;
}
persistenceContext.AddEntry(
result,
isReadOnly ? Status.ReadOnly : Status.Loaded,
values,
null,
id,
version,
LockMode.None,
true,
subclassPersister,
false,
entry.AreLazyPropertiesUnfetched);
subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session);
persistenceContext.InitializeNonLazyCollections();
// upgrade the lock if necessary:
//lock(result, lockMode);
//PostLoad is needed for EJB3
//TODO: reuse the PostLoadEvent...
PostLoadEvent postLoadEvent = new PostLoadEvent(session);
postLoadEvent.Entity = result;
postLoadEvent.Id = id;
postLoadEvent.Persister = persister;
IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
listeners[i].OnPostLoad(postLoadEvent);
}
return(result);
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (ReplaceOrderRequest)recorderContext.Request;
var profile = persistenceContext.Load <PatientProfile>(request.Requisition.Patient.PatientProfileRef, EntityLoadFlags.None);
var cancelledOrder = persistenceContext.Load <Order>(request.OrderRef, EntityLoadFlags.None);
var response = (ReplaceOrderResponse)recorderContext.Response;
var newOrder = persistenceContext.Load <Order>(response.Order.OrderRef, EntityLoadFlags.None);
return(new ReplaceOrderOperationData(Operations.Replace, profile, cancelledOrder, newOrder));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (PlaceOrderRequest)recorderContext.Request;
var profile = persistenceContext.Load <PatientProfile>(request.Requisition.Patient.PatientProfileRef, EntityLoadFlags.None);
var response = (PlaceOrderResponse)recorderContext.Response;
var order = persistenceContext.Load <Order>(response.Order.OrderRef, EntityLoadFlags.None);
Platform.Log(LogLevel.Debug, "!!!!!!!!!!!!!!!!!!New Order Trigger!!!!!!!!!!!!!!!!!!");
Platform.Log(LogLevel.Debug, order.AccessionNumber);
return(new OperationData(Operations.New, profile, order));
}
private static int DeletePractitioner(ExternalPractitioner practitioner, int stage, IPersistenceContext context)
{
Platform.Log(LogLevel.Debug, "Attempting to delete practitioner {0}", practitioner.OID);
try
{
// since there are no more referencing orders or visits, we can delete the practitioner
// and its contact points
context.GetBroker <IExternalPractitionerBroker>().Delete(practitioner);
// force the delete to occur, to ensure it will succeed
context.SynchState();
// merge completed
return(-1);
}
catch (PersistenceException e)
{
throw new MergeProcessor.CannotDeleteException(e);
}
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (UnmergeOrderRequest)recorderContext.Request;
var order = persistenceContext.Load <Order>(request.OrderRef, EntityLoadFlags.None);
var patientProfile = order.Procedures.First().PatientProfile; // choose patient profile from one procedure?
return(new OperationData(Operations.Unmerge, patientProfile, order));
}
protected override bool ShouldCapture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (MergeOrderRequest)recorderContext.Request;
return(!(request.DryRun || request.ValidationOnly));
}
private static IList <Visit> GetVisitBatch(ExternalPractitioner practitioner, Action <VisitSearchCriteria> priorityFilter, int batchSize, IPersistenceContext context)
{
var visitsWhere = new VisitSearchCriteria();
priorityFilter(visitsWhere);
var practitionersWhere = new VisitPractitionerSearchCriteria();
practitionersWhere.Practitioner.EqualTo(practitioner);
return(context.GetBroker <IVisitBroker>().FindByVisitPractitioner(new VisitSearchCriteria(), practitionersWhere, new SearchResultPage(0, batchSize)));
}
/// <summary>
/// Given that there is a pre-existing proxy.
/// Initialize it if necessary; narrow if necessary.
/// </summary>
private object ReturnNarrowedProxy(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options, IPersistenceContext persistenceContext, object proxy)
{
log.Debug("entity proxy found in session cache");
var castedProxy = (INHibernateProxy)proxy;
ILazyInitializer li = castedProxy.HibernateLazyInitializer;
if (li.Unwrap)
{
return(li.GetImplementation());
}
object impl = null;
if (!options.IsAllowProxyCreation)
{
impl = Load(@event, persister, keyToLoad, options);
// NH Different behavior : NH-1252
if (impl == null && !options.IsAllowNulls)
{
@event.Session.Factory.EntityNotFoundDelegate.HandleEntityNotFound(persister.EntityName, keyToLoad.Identifier);
}
}
if (impl == null && !options.IsAllowProxyCreation && options.ExactPersister)
{
// NH Different behavior : NH-1252
return(null);
}
return(persistenceContext.NarrowProxy(castedProxy, persister, keyToLoad, impl));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (MergeOrderRequest)recorderContext.Request;
var destOrder = persistenceContext.Load <Order>(request.DestinationOrderRef, EntityLoadFlags.None);
var patientProfile = destOrder.Procedures.First().PatientProfile; // choose patient profile from one procedure?
var sourceOrders = request.SourceOrderRefs.Select(r => persistenceContext.Load <Order>(r, EntityLoadFlags.None));
return(new MergeOrderOperationData(Operations.Merge, patientProfile, destOrder, sourceOrders));
}
private static IList <Order> GetOrderBatchByResultRecipient(ExternalPractitioner practitioner, Action <OrderSearchCriteria> priorityFilter, int batchSize, IPersistenceContext context)
{
var ordersWhere = new OrderSearchCriteria();
priorityFilter(ordersWhere);
var recipientWhere = new ResultRecipientSearchCriteria();
recipientWhere.PractitionerContactPoint.In(practitioner.ContactPoints);
return(context.GetBroker <IOrderBroker>().FindByResultRecipient(ordersWhere, recipientWhere, new SearchResultPage(0, batchSize)));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var request = (ModifyOrderRequest)recorderContext.Request;
var profile = persistenceContext.Load <PatientProfile>(request.Requisition.Patient.PatientProfileRef, EntityLoadFlags.None);
var order = persistenceContext.Load <Order>(request.Requisition.OrderRef, EntityLoadFlags.None);
IncludeChangeSetFor(order);
IncludeChangeSetFor(typeof(Procedure));
return(new OperationData(Operations.Modify, profile, order));
}
private static IList <Order> GetOrderBatchByOrderingPractitioner(ExternalPractitioner practitioner, Action <OrderSearchCriteria> priorityFilter, int batchSize, IPersistenceContext context)
{
var ordersWhere = new OrderSearchCriteria();
priorityFilter(ordersWhere);
ordersWhere.OrderingPractitioner.EqualTo(practitioner);
return(context.GetBroker <IOrderBroker>().Find(ordersWhere, new SearchResultPage(0, batchSize)));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var response = (GetOrderRequisitionForEditResponse)recorderContext.Response;
var patientProfile = persistenceContext.Load <PatientProfile>(response.Requisition.Patient.PatientProfileRef, EntityLoadFlags.None);
var order = persistenceContext.Load <Order>(response.Requisition.OrderRef, EntityLoadFlags.None);
return(new OperationData(Operations.OpenForModifyOrReplace, patientProfile, order));
}
public ModalityProcedureStepSummary CreateProcedureStepSummary(ModalityProcedureStep mps, IPersistenceContext context)
{
var psSummary = new ProcedureStepAssembler().CreateProcedureStepSummary(mps, context);
return(new ModalityProcedureStepSummary(psSummary, mps.Description));
}
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;
}
public RoomService(IPersistenceContext persistenceContext, IServiceLocator serviceLocator) :
base(persistenceContext, serviceLocator)
{
}
public StudyStorage LoadStudyStorage(IPersistenceContext context)
{
return(StudyStorage.Load(StudyStorageKey));
}
protected override OperationData Capture(IServiceOperationRecorderContext recorderContext, IPersistenceContext persistenceContext)
{
var response = (UpdatePatientProfileResponse)recorderContext.Response;
var patientProfile = persistenceContext.Load <PatientProfile>(response.PatientProfile.PatientProfileRef, EntityLoadFlags.None);
IncludeChangeSetFor(patientProfile);
IncludeChangeSetFor(patientProfile.Patient);
return(new OperationData(Operations.Update, patientProfile));
}
public IList <StudyStorageLocation> LoadStudyLocations(IPersistenceContext context)
{
StudyStorage storage = LoadStudyStorage(context);
return(StudyStorageLocation.FindStorageLocations(context, storage));
}
public PersistentWorkflow(IPersistenceContext context)
{
_context = context;
}
