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; }