public bool CanCancelReportingStep(ReportingWorklistItemKey itemKey) { // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) { return(false); } var procedureStep = this.PersistenceContext.Load <ProcedureStep>(itemKey.ProcedureStepRef); var isAssignedToMe = procedureStep.AssignedStaff != null && Equals(procedureStep.AssignedStaff, this.CurrentUserStaff); if (isAssignedToMe) { // Report is assigned to current user, allow cancel only if user has Create or Cancel token if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Create) && !Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Cancel)) { return(false); } } else { // Report not assigned to current user, allow cancel only if user has Cancel token if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Cancel)) { return(false); } } return(CanExecuteOperation(new Operations.CancelReportingStep(), itemKey)); }
private bool CanExecuteOperation(Operations.ReportingOperation op, ReportingWorklistItemKey itemKey, bool disableIfSubmitForReview) { // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) { return(false); } var procedureStep = this.PersistenceContext.Load <ProcedureStep>(itemKey.ProcedureStepRef); // for now, all of these operations assume they are operating on a ReportingProcedureStep // this may need to change in future if (!procedureStep.Is <ReportingProcedureStep>()) { return(false); } // Special Case: // If the user has the SubmitForReview token and the step is unassigned, disable the operation if (disableIfSubmitForReview && procedureStep.AssignedStaff == null && Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.SubmitForReview)) { return(false); } return(op.CanExecute(procedureStep.As <ReportingProcedureStep>(), this.CurrentUserStaff)); }
public bool CanCompleteInterpretationForTranscription(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Create)) { return(false); } return(CanExecuteOperation(new Operations.CompleteInterpretationForTranscription(), itemKey)); }
public bool CanStartTranscriptionReview(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Create)) { return(false); } return(CanExecuteOperation(new Operations.StartTranscriptionReview(), itemKey)); }
public bool CanReviseUnpublishedReport(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Verify)) { return(false); } return(CanExecuteOperation(new Operations.ReviseUnpublishedReport(), itemKey)); }
public bool CanCreateAddendum(ReportingWorklistItemKey itemKey) { // special case: procedure step not known, but procedure is if (itemKey.ProcedureRef != null) { var procedure = this.PersistenceContext.Load <Procedure>(itemKey.ProcedureRef); return((new Operations.CreateAddendum()).CanExecute(procedure, CurrentUserStaff)); } return(false); }
public bool CanCompleteVerification(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Verify)) { return(false); } // If the submit for review token is present, do not enable verification, defer to // revise report. This ensures items submitted with or without a supervisor have a // consistent set of operations. return(CanExecuteOperation(new Operations.CompleteVerification(), itemKey, true)); }
public bool CanPublishReport(ReportingWorklistItemKey itemKey) { #if DEBUG if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Development.TestPublishReport)) { return(false); } return(CanExecuteOperation(new Operations.PublishReport(), itemKey)); #else return(false); #endif }
public bool CanCompleteDowntimeProcedure(ReportingWorklistItemKey itemKey) { // does the item have a procedure ref, or is it just a patient? if (itemKey.ProcedureRef == null) { return(false); } var procedure = this.PersistenceContext.Load <Procedure>(itemKey.ProcedureRef); // is the procedure a downtime proc, and is it performed and documented?? return(procedure.DowntimeRecoveryMode && procedure.IsPerformed && procedure.IsDocumented); }
public bool CanReassignProcedureStep(ReportingWorklistItemKey itemKey) { if (itemKey.ProcedureStepRef == null) { return(false); } var procedureStep = this.PersistenceContext.Load <ProcedureStep>(itemKey.ProcedureStepRef); if (procedureStep.Is <ProtocolProcedureStep>()) { return(Thread.CurrentPrincipal.IsInRole(Common.AuthorityTokens.Workflow.Protocol.Reassign)); } return(false); }
public bool CanSendReportToQueue(ReportingWorklistItemKey itemKey) { // does the item have a procedure ref, or is it just a patient? if (itemKey.ProcedureRef == null) { return(false); } // does the procedure have an active report var procedure = this.PersistenceContext.Load <Procedure>(itemKey.ProcedureRef); if (procedure.ActiveReport == null) { return(false); } return(true); }
public bool CanReassignProcedureStep(ReportingWorklistItemKey itemKey) { if (itemKey.ProcedureStepRef == null) { return(false); } var procedureStep = this.PersistenceContext.Load <ProcedureStep>(itemKey.ProcedureStepRef); // bug #6418 - this operation doesn't apply to transcription steps, because it doesn't make any sense to assign // a transcription step to a radiologist if (procedureStep.Is <TranscriptionStep>()) { return(false); } if (procedureStep.Is <ReportingProcedureStep>()) { return(Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Reassign) && !(procedureStep.Is <PublicationStep>())); } return(false); }
private bool CanExecuteOperation(Operations.ReportingOperation op, ReportingWorklistItemKey itemKey) { return(CanExecuteOperation(op, itemKey, false)); }
public bool CanReviseResidentReport(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.SubmitForReview)) return false; return CanExecuteOperation(new Operations.ReviseResidentReport(), itemKey); }
public bool CanCompleteDowntimeProcedure(ReportingWorklistItemKey itemKey) { // does the item have a procedure ref, or is it just a patient? if (itemKey.ProcedureRef == null) return false; var procedure = this.PersistenceContext.Load<Procedure>(itemKey.ProcedureRef); // is the procedure a downtime proc, and is it performed and documented?? return procedure.DowntimeRecoveryMode && procedure.IsPerformed && procedure.IsDocumented; }
private bool CanExecuteOperation(TranscriptionOperations.TranscriptionOperation op, ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Transcription.Create)) { return(false); } // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) { return(false); } var step = this.PersistenceContext.Load <ProcedureStep>(itemKey.ProcedureStepRef); // for now, all of these operations assume they are operating on a // this may need to change in future if (!step.Is <TranscriptionStep>()) { return(false); } return(op.CanExecute(step.As <TranscriptionStep>(), this.CurrentUserStaff)); }
public bool CanSubmitTranscriptionForReview(ReportingWorklistItemKey itemKey) { return(CanExecuteOperation(new TranscriptionOperations.SubmitTranscriptionForReview(), itemKey)); }
public bool CanRejectTranscription(ReportingWorklistItemKey itemKey) { return CanExecuteOperation(new TranscriptionOperations.RejectTranscription(), itemKey); }
public bool CanReviseUnpublishedReport(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Verify)) return false; return CanExecuteOperation(new Operations.ReviseUnpublishedReport(), itemKey); }
public bool CanCompleteInterpretationAndVerify(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Verify)) return false; return CanExecuteOperation(new Operations.CompleteInterpretationAndVerify(), itemKey); }
public bool CanPublishReport(ReportingWorklistItemKey itemKey) { #if DEBUG if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Development.TestPublishReport)) return false; return CanExecuteOperation(new Operations.PublishReport(), itemKey); #else return false; #endif }
public bool CanSaveReport(ReportingWorklistItemKey itemKey) { return CanExecuteOperation(new Operations.SaveReport(), itemKey); }
public bool CanReassignProcedureStep(ReportingWorklistItemKey itemKey) { if (itemKey.ProcedureStepRef == null) return false; var procedureStep = this.PersistenceContext.Load<ProcedureStep>(itemKey.ProcedureStepRef); // bug #6418 - this operation doesn't apply to transcription steps, because it doesn't make any sense to assign // a transcription step to a radiologist if (procedureStep.Is<TranscriptionStep>()) return false; if (procedureStep.Is<ReportingProcedureStep>()) return Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Reassign) && !(procedureStep.Is<PublicationStep>()); return false; }
private bool CanExecuteOperation(Operations.ReportingOperation op, ReportingWorklistItemKey itemKey, bool disableIfSubmitForReview) { // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) return false; var procedureStep = this.PersistenceContext.Load<ProcedureStep>(itemKey.ProcedureStepRef); // for now, all of these operations assume they are operating on a ReportingProcedureStep // this may need to change in future if (!procedureStep.Is<ReportingProcedureStep>()) return false; // Special Case: // If the user has the SubmitForReview token and the step is unassigned, disable the operation if (disableIfSubmitForReview && procedureStep.AssignedStaff == null && Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.SubmitForReview)) { return false; } return op.CanExecute(procedureStep.As<ReportingProcedureStep>(), this.CurrentUserStaff); }
private bool CanExecuteOperation(Operations.ReportingOperation op, ReportingWorklistItemKey itemKey) { return CanExecuteOperation(op, itemKey, false); }
public bool CanCancelReportingStep(ReportingWorklistItemKey itemKey) { // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) return false; var procedureStep = this.PersistenceContext.Load<ProcedureStep>(itemKey.ProcedureStepRef); var isAssignedToMe = procedureStep.AssignedStaff != null && Equals(procedureStep.AssignedStaff, this.CurrentUserStaff); if (isAssignedToMe) { // Report is assigned to current user, allow cancel only if user has Create or Cancel token if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Create) && !Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Cancel)) return false; } else { // Report not assigned to current user, allow cancel only if user has Cancel token if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Cancel)) return false; } return CanExecuteOperation(new Operations.CancelReportingStep(), itemKey); }
public bool CanSubmitTranscriptionForReview(ReportingWorklistItemKey itemKey) { return CanExecuteOperation(new TranscriptionOperations.SubmitTranscriptionForReview(), itemKey); }
public bool CanCreateAddendum(ReportingWorklistItemKey itemKey) { // special case: procedure step not known, but procedure is if (itemKey.ProcedureRef != null) { var procedure = this.PersistenceContext.Load<Procedure>(itemKey.ProcedureRef); return (new Operations.CreateAddendum()).CanExecute(procedure, CurrentUserStaff); } return false; }
private bool CanExecuteOperation(TranscriptionOperations.TranscriptionOperation op, ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Transcription.Create)) return false; // if there is no proc step ref, operation is not available if (itemKey.ProcedureStepRef == null) return false; var step = this.PersistenceContext.Load<ProcedureStep>(itemKey.ProcedureStepRef); // for now, all of these operations assume they are operating on a // this may need to change in future if (!step.Is<TranscriptionStep>()) return false; return op.CanExecute(step.As<TranscriptionStep>(), this.CurrentUserStaff); }
public bool CanCompleteVerification(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Verify)) return false; // If the submit for review token is present, do not enable verification, defer to // revise report. This ensures items submitted with or without a supervisor have a // consistent set of operations. return CanExecuteOperation(new Operations.CompleteVerification(), itemKey, true); }
public bool CanRejectTranscription(ReportingWorklistItemKey itemKey) { return(CanExecuteOperation(new TranscriptionOperations.RejectTranscription(), itemKey)); }
public bool CanSaveReport(ReportingWorklistItemKey itemKey) { return(CanExecuteOperation(new Operations.SaveReport(), itemKey)); }
public bool CanStartTranscriptionReview(ReportingWorklistItemKey itemKey) { if (!Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Workflow.Report.Create)) return false; return CanExecuteOperation(new Operations.StartTranscriptionReview(), itemKey); }
public bool CanSendReportToQueue(ReportingWorklistItemKey itemKey) { // does the item have a procedure ref, or is it just a patient? if (itemKey.ProcedureRef == null) return false; // does the procedure have an active report var procedure = this.PersistenceContext.Load<Procedure>(itemKey.ProcedureRef); if (procedure.ActiveReport == null) return false; return true; }