Beispiel #1
0
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToAccept;
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.m_TumorNucleiPercentage) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "The results cannot be accepted because the Tumor Nuclei Percentage has no value.";
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoesFinalSummaryResultMatch(accessionOrder, this.m_Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskAccept;
                }
            }

            return(result);
        }
        private void AreTestResultsPresent(AccessionOrder accessionOrder, Audit.Model.AuditResult result)
        {
            if (string.IsNullOrEmpty(this.m_JAK2V617FResult) == true)
            {
                result.Status   = Audit.Model.AuditStatusEnum.Failure;
                result.Message += NotFilledMessage("JAK2V617FResult");
            }

            if (string.IsNullOrEmpty(this.m_JAK2Exon1214Result) == true)
            {
                result.Status   = Audit.Model.AuditStatusEnum.Failure;
                result.Message += NotFilledMessage("JAK2Exon1214Result");
            }

            if (string.IsNullOrEmpty(this.m_MPLResult) == true)
            {
                result.Status   = Audit.Model.AuditStatusEnum.Failure;
                result.Message += NotFilledMessage("MPLResult");
            }

            if (string.IsNullOrEmpty(this.m_CalreticulinMutationAnalysisResult) == true)
            {
                result.Status   = Audit.Model.AuditStatusEnum.Failure;
                result.Message += NotFilledMessage("CalreticulinMutationAnalysisResult");
            }
        }
Beispiel #3
0
 public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
 {
     Audit.Model.AuditResult auditResult = base.IsOkToFinalize(accessionOrder);
     if (auditResult.Status == Audit.Model.AuditStatusEnum.OK)
     {
         if (string.IsNullOrEmpty(this.m_ResultCode) == true)
         {
             auditResult.Status  = Audit.Model.AuditStatusEnum.Failure;
             auditResult.Message = "This case cannot be finalized because the results have not been set.";
         }
         else
         {
             YellowstonePathology.Business.Test.KRASStandardReflex.KRASStandardReflexTest krasStandardReflexTest = new KRASStandardReflex.KRASStandardReflexTest();
             if (accessionOrder.PanelSetOrderCollection.Exists(krasStandardReflexTest.PanelSetId, this.OrderedOnId, true) == false)
             {
                 YellowstonePathology.Business.Facility.Model.Facility ypi = YellowstonePathology.Business.Facility.Model.FacilityCollection.Instance.GetByFacilityId("YPIBLGS");
                 if (this.TechnicalComponentFacilityId == ypi.FacilityId)
                 {
                     if (string.IsNullOrEmpty(this.TumorNucleiPercentage) == true)
                     {
                         if (accessionOrder.PanelSetOrderCollection.Exists(krasStandardReflexTest.PanelSetId) == false)
                         {
                             auditResult.Status  = Audit.Model.AuditStatusEnum.Failure;
                             auditResult.Message = "This case cannot be finalized because the Tumor Nuclei Percent is not set.";
                         }
                     }
                 }
             }
         }
     }
     return(auditResult);
 }
Beispiel #4
0
        public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.m_Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToFinal;
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.m_TumorNucleiPercentage) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "The results cannot be finalized because the Tumor Nuclei Percentage has no value.";
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoesFinalSummaryResultMatch(accessionOrder, this.m_Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskFinal;
                }
            }

            return(result);
        }
Beispiel #5
0
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.TumorNucleiPercentage) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "The results cannot be accepted because the Tumor Nuclei Percentage has no value.";
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreComponentTestOrdersAccepted(accessionOrder, result);
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreTestResultsPresent(accessionOrder, result);
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoComponentTestResultsMatchPreviousResults(accessionOrder, this, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskAccept;
                }
            }

            return(result);
        }
Beispiel #6
0
        public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.TumorNucleiPercentage) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "The results cannot be finalized because the Tumor Nuclei Percentage has no value.";
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreComponentTestOrdersFinal(accessionOrder, result);
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreTestResultsPresent(accessionOrder, result);
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoComponentTestResultsMatchPreviousResults(accessionOrder, this, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskFinal;
                }
            }
            return(result);
        }
Beispiel #7
0
 public void DoesPDL1SP142ResultMatch(string result, Audit.Model.AuditResult auditResult)
 {
     if (this.Final == true && this.m_PDL1SP142Result != result)
     {
         auditResult.Status   = Audit.Model.AuditStatusEnum.Warning;
         auditResult.Message += MismatchMessage(this.PanelSetName);
     }
 }
 public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
 {
     Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
     if (result.Status == Audit.Model.AuditStatusEnum.OK)
     {
         this.AreTestResultsPresent(accessionOrder, result);
     }
     return(result);
 }
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreTestResultsPresent(accessionOrder, result);
            }

            return(result);
        }
Beispiel #10
0
 public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
 {
     Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
     if (result.Status == Audit.Model.AuditStatusEnum.OK)
     {
         if (string.IsNullOrEmpty(this.m_Result) == true)
         {
             result.Status  = Audit.Model.AuditStatusEnum.Failure;
             result.Message = UnableToFinal;
         }
     }
     return(result);
 }
 public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
 {
     Audit.Model.AuditResult auditResult = base.IsOkToFinalize(accessionOrder);
     if (auditResult.Status == Audit.Model.AuditStatusEnum.OK)
     {
         if (string.IsNullOrEmpty(this.m_ResultCode) == true)
         {
             auditResult.Status  = Audit.Model.AuditStatusEnum.Failure;
             auditResult.Message = "This case cannot be finalized because the results have not been set.";
         }
     }
     return(auditResult);
 }
Beispiel #12
0
 public virtual Audit.Model.AuditResult IsOkToSetResults(YellowstonePathology.Business.Test.AccessionOrder accessionOrder, YellowstonePathology.Business.Test.LynchSyndrome.PanelSetOrderLynchSyndromeEvaluation panelSetOrderLynchSyndromeEvaluation)
 {
     Audit.Model.AuditResult result = panelSetOrderLynchSyndromeEvaluation.IsOkToSetResults();
     if (result.Status == Audit.Model.AuditStatusEnum.OK)
     {
         Rules.MethodResult hasIHCResult = this.HasFinalIHCResult(accessionOrder, panelSetOrderLynchSyndromeEvaluation);
         if (hasIHCResult.Success == false)
         {
             result.Status  = Audit.Model.AuditStatusEnum.Failure;
             result.Message = hasIHCResult.Message;
         }
     }
     return(result);
 }
Beispiel #13
0
 public override Audit.Model.AuditResult IsOkToSetResults(AccessionOrder accessionOrder, PanelSetOrderLynchSyndromeEvaluation panelSetOrderLynchSyndromeEvaluation)
 {
     Audit.Model.AuditResult result = base.IsOkToSetResults(accessionOrder, panelSetOrderLynchSyndromeEvaluation);
     if (result.Status == Audit.Model.AuditStatusEnum.OK)
     {
         Rules.MethodResult methResult = this.HasFinalMethResult(accessionOrder, panelSetOrderLynchSyndromeEvaluation);
         if (methResult.Success == false)
         {
             result.Status  = Audit.Model.AuditStatusEnum.Failure;
             result.Message = methResult.Message;
         }
     }
     return(result);
 }
Beispiel #14
0
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToAccept;
                }
            }

            return(result);
        }
Beispiel #15
0
        public override Audit.Model.AuditResult IsOkToSetPreviousResults(PanelSetOrder panelSetOrder, AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToSetPreviousResults(panelSetOrder, accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                EGFRMutationAnalysisTestOrder egfrMutationAnalysisTestOrder = (EGFRMutationAnalysisTestOrder)panelSetOrder;
                this.DoesFinalSummaryResultMatch(accessionOrder, egfrMutationAnalysisTestOrder.Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskSetPreviousResults;
                }
            }

            return(result);
        }
        public override Audit.Model.AuditResult IsOkToSetPreviousResults(PanelSetOrder panelSetOrder, AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToSetPreviousResults(panelSetOrder, accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                ROS1ByFISHTestOrder pso = (ROS1ByFISHTestOrder)panelSetOrder;
                this.DoesFinalSummaryResultMatch(accessionOrder, pso.Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskSetPreviousResults;
                }
            }

            return(result);
        }
Beispiel #17
0
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.m_JAK2Exon1214Result) == true &&
                    string.IsNullOrEmpty(this.m_JAK2V617FResult) == true &&
                    string.IsNullOrEmpty(this.m_MPLResult) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "Unable to accept as the results have not been set.";
                }
            }

            return(result);
        }
Beispiel #18
0
 public Audit.Model.AuditResult IsOkToSetResults()
 {
     Audit.Model.AuditResult result = new Audit.Model.AuditResult();
     result.Status = Audit.Model.AuditStatusEnum.OK;
     if (this.LynchSyndromeEvaluationType == LSEType.NOTSET)
     {
         result.Status  = Audit.Model.AuditStatusEnum.Failure;
         result.Message = "Results may not be set as the Indication is not selected.";
     }
     else if (this.Accepted == true)
     {
         result.Status  = Audit.Model.AuditStatusEnum.Failure;
         result.Message = "Results may not be set as the results have been accepted.";
     }
     return(result);
 }
        public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.m_Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToFinal;
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.Indication) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = "The results cannot be finalized because the BRAF indicator is not set.";
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                YellowstonePathology.Business.Test.KRASStandardReflex.KRASStandardReflexTest krasStandardReflexTest = new KRASStandardReflex.KRASStandardReflexTest();
                if (accessionOrder.PanelSetOrderCollection.Exists(krasStandardReflexTest.PanelSetId, this.OrderedOnId, true) == false)
                {
                    if (string.IsNullOrEmpty(this.TumorNucleiPercentage) == true)
                    {
                        result.Status  = Audit.Model.AuditStatusEnum.Failure;
                        result.Message = "This case cannot be finalized because the Tumor Nuclei Percent is not set.";
                    }
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoesFinalSummaryResultMatch(accessionOrder, this.m_Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskFinal;
                }
            }

            return(result);
        }
 public override YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
 {
     Audit.Model.AuditResult result = base.IsOkToFinalize(accessionOrder);
     if (result.Status == Audit.Model.AuditStatusEnum.OK)
     {
         if (string.IsNullOrEmpty(this.m_Result) == true)
         {
             result.Status  = Audit.Model.AuditStatusEnum.Failure;
             result.Message = UnableToFinal + Environment.NewLine;
         }
         if (string.IsNullOrEmpty(this.m_Karyotype) == true)
         {
             result.Status   = Audit.Model.AuditStatusEnum.Failure;
             result.Message += "This case cannot be finalized because the Karyotype has not been set.";
         }
     }
     return(result);
 }
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToAccept + Environment.NewLine;
                }
                if (string.IsNullOrEmpty(this.m_Karyotype) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += "This case cannot be accepted because the Karyotype has not been set.";
                }
            }

            return(result);
        }
Beispiel #22
0
        public override Audit.Model.AuditResult IsOkToSetPreviousResults(PanelSetOrder panelSetOrder, AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToSetPreviousResults(panelSetOrder, accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.AreComponentTestOrdersAccepted(accessionOrder, result);
            }

            /*if (result.Status == Audit.Model.AuditStatusEnum.OK)
             * {
             *  this.DoComponentTestResultsMatchPreviousResults(accessionOrder, (EGFRToALKReflexAnalysisTestOrder)panelSetOrder, result);
             *  if (result.Status == Audit.Model.AuditStatusEnum.Warning)
             *  {
             *      result.Message += AskSetPreviousResults;
             *  }
             * }*/

            return(result);
        }
Beispiel #23
0
        public override AuditResult IsOkToFinalize(AccessionOrder accessionOrder)
        {
            AuditResult result = new Audit.Model.AuditResult();

            result.Status = AuditStatusEnum.OK;

            YellowstonePathology.Business.Rules.MethodResult methodResult = IsOkToFinalize();
            if (methodResult.Success == false)
            {
                result.Status  = AuditStatusEnum.Failure;
                result.Message = methodResult.Message;
            }

            if (result.Status == AuditStatusEnum.OK)
            {
                result = base.IsOkToFinalize(accessionOrder);
            }

            return(result);
        }
Beispiel #24
0
        public Audit.Model.AuditResult IsOkToFinalize(YellowstonePathology.Business.Test.AccessionOrder accessionOrder,
                                                      PanelOrderCytology panelOrderToFinalize,
                                                      YellowstonePathology.Business.User.SystemIdentity systemIdentity,
                                                      YellowstonePathology.Business.Rules.ExecutionStatus executionStatus)
        {
            Audit.Model.AuditCollection auditCollection = new Audit.Model.AuditCollection();
            auditCollection.Add(new Audit.Model.DistributionCanBeSetAudit(accessionOrder));
            auditCollection.Add(new Audit.Model.CanFinalizeCytologyPanelOrderAudit(panelOrderToFinalize, this, accessionOrder, systemIdentity, executionStatus));
            Audit.Model.AuditResult auditResult = auditCollection.Run2();

            if (auditResult.Status == Audit.Model.AuditStatusEnum.Failure)
            {
                if (executionStatus.Halted == false)
                {
                    executionStatus.AddMessage(auditResult.Message, true);
                    executionStatus.ShowMessage = true;
                    executionStatus.Halted      = true;
                }
            }
            return(auditResult);
        }
        public override Audit.Model.AuditResult IsOkToAccept(AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = base.IsOkToAccept(accessionOrder);
            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                if (string.IsNullOrEmpty(this.Result) == true)
                {
                    result.Status  = Audit.Model.AuditStatusEnum.Failure;
                    result.Message = UnableToAccept;
                }
            }

            if (result.Status == Audit.Model.AuditStatusEnum.OK)
            {
                this.DoesFinalSummaryResultMatch(accessionOrder, this.m_Result, result);
                if (result.Status == Audit.Model.AuditStatusEnum.Warning)
                {
                    result.Message += AskAccept;
                }
            }

            return(result);
        }
Beispiel #26
0
        private void AreTestResultsPresent(AccessionOrder accessionOrder, Audit.Model.AuditResult result)
        {
            YellowstonePathology.Business.Test.PDL122C3.PDL122C3Test pdl122C3Test = new PDL122C3.PDL122C3Test();
            YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest egfrMutationAnalysisTest = new YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest();
            YellowstonePathology.Business.Test.ROS1ByFISH.ROS1ByFISHTest ros1ByfishTest = new ROS1ByFISH.ROS1ByFISHTest();
            YellowstonePathology.Business.Test.ALKForNSCLCByFISH.ALKForNSCLCByFISHTest       alkTest  = new ALKForNSCLCByFISH.ALKForNSCLCByFISHTest();
            YellowstonePathology.Business.Test.BRAFMutationAnalysis.BRAFMutationAnalysisTest brafTest = new BRAFMutationAnalysis.BRAFMutationAnalysisTest();
            YellowstonePathology.Business.Test.PDL1SP142.PDL1SP142Test pdl1SP142Test = new PDL1SP142.PDL1SP142Test();

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl122C3Test.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_PDL122C3Result) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("PDL122C3Result");
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(egfrMutationAnalysisTest.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_EGFRMutationAnalysisResult) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("EGFRMutationAnalysisResult");
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(ros1ByfishTest.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_ROS1ByFISHResult) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("ROS1ByFISHResult");
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(alkTest.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_ALKForNSCLCByFISHResult) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("ALKForNSCLCByFISHResult");
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(brafTest.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_BRAFMutationAnalysisResult) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("BRAFMutationAnalysisResult");
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl1SP142Test.PanelSetId) == true)
            {
                if (string.IsNullOrEmpty(this.m_PDL1SP142Result) == true)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFilledMessage("PDL1SP142Result");
                }
            }
        }
Beispiel #27
0
        private void AreComponentTestOrdersFinal(AccessionOrder accessionOrder, Audit.Model.AuditResult result)
        {
            YellowstonePathology.Business.Test.PDL122C3.PDL122C3Test pdl122C3Test = new PDL122C3.PDL122C3Test();
            YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest egfrMutationAnalysisTest = new YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest();
            YellowstonePathology.Business.Test.ROS1ByFISH.ROS1ByFISHTest ros1ByfishTest = new ROS1ByFISH.ROS1ByFISHTest();
            YellowstonePathology.Business.Test.ALKForNSCLCByFISH.ALKForNSCLCByFISHTest       alkTest  = new ALKForNSCLCByFISH.ALKForNSCLCByFISHTest();
            YellowstonePathology.Business.Test.BRAFMutationAnalysis.BRAFMutationAnalysisTest brafTest = new BRAFMutationAnalysis.BRAFMutationAnalysisTest();
            YellowstonePathology.Business.Test.PDL1SP142.PDL1SP142Test pdl1SP142Test = new PDL1SP142.PDL1SP142Test();

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl122C3Test.PanelSetId) == true)
            {
                Test.PDL122C3.PDL122C3TestOrder pdl122C3TestOrder = (PDL122C3.PDL122C3TestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(pdl122C3Test.PanelSetId);
                if (pdl122C3TestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(pdl122C3TestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(egfrMutationAnalysisTest.PanelSetId) == true)
            {
                Test.EGFRMutationAnalysis.EGFRMutationAnalysisTestOrder egfrMutationAnalysisTestOrder = (EGFRMutationAnalysis.EGFRMutationAnalysisTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(egfrMutationAnalysisTest.PanelSetId);
                if (egfrMutationAnalysisTestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(egfrMutationAnalysisTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(ros1ByfishTest.PanelSetId) == true)
            {
                Test.ROS1ByFISH.ROS1ByFISHTestOrder ros1ByFISHTestOrder = (ROS1ByFISH.ROS1ByFISHTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(ros1ByfishTest.PanelSetId);
                if (ros1ByFISHTestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(ros1ByFISHTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(alkTest.PanelSetId) == true)
            {
                Test.ALKForNSCLCByFISH.ALKForNSCLCByFISHTestOrder alkTestOrder = (ALKForNSCLCByFISH.ALKForNSCLCByFISHTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(alkTest.PanelSetId);
                if (alkTestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(alkTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(brafTest.PanelSetId) == true)
            {
                Test.BRAFMutationAnalysis.BRAFMutationAnalysisTestOrder brafTestOrder = (BRAFMutationAnalysis.BRAFMutationAnalysisTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(brafTest.PanelSetId);
                if (brafTestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(brafTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl1SP142Test.PanelSetId) == true)
            {
                Test.PDL1SP142.PDL1SP142TestOrder pdl1SP142TestOrder = (PDL1SP142.PDL1SP142TestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(pdl1SP142Test.PanelSetId);
                if (pdl1SP142TestOrder.Final == false)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Failure;
                    result.Message += NotFinaledMessage(pdl1SP142TestOrder.PanelSetName);
                }
            }
        }
Beispiel #28
0
        private void DoComponentTestResultsMatchPreviousResults(AccessionOrder accessionOrder, EGFRToALKReflexAnalysisTestOrder panelSetOrder, Audit.Model.AuditResult result)
        {
            YellowstonePathology.Business.Test.PDL122C3.PDL122C3Test pdl122C3Test = new PDL122C3.PDL122C3Test();
            YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest egfrMutationAnalysisTest = new YellowstonePathology.Business.Test.EGFRMutationAnalysis.EGFRMutationAnalysisTest();
            YellowstonePathology.Business.Test.ROS1ByFISH.ROS1ByFISHTest ros1ByfishTest = new ROS1ByFISH.ROS1ByFISHTest();
            YellowstonePathology.Business.Test.ALKForNSCLCByFISH.ALKForNSCLCByFISHTest       alkTest  = new ALKForNSCLCByFISH.ALKForNSCLCByFISHTest();
            YellowstonePathology.Business.Test.BRAFMutationAnalysis.BRAFMutationAnalysisTest brafTest = new BRAFMutationAnalysis.BRAFMutationAnalysisTest();
            YellowstonePathology.Business.Test.PDL1SP142.PDL1SP142Test pdl1SP142Test = new PDL1SP142.PDL1SP142Test();

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl122C3Test.PanelSetId) == true)
            {
                Test.PDL122C3.PDL122C3TestOrder pdl122C3TestOrder = (PDL122C3.PDL122C3TestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(pdl122C3Test.PanelSetId);
                if (pdl122C3TestOrder.Result != panelSetOrder.PDL122C3Result)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(pdl122C3TestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(egfrMutationAnalysisTest.PanelSetId) == true)
            {
                Test.EGFRMutationAnalysis.EGFRMutationAnalysisTestOrder egfrMutationAnalysisTestOrder = (EGFRMutationAnalysis.EGFRMutationAnalysisTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(egfrMutationAnalysisTest.PanelSetId);
                if (egfrMutationAnalysisTestOrder.Result != panelSetOrder.EGFRMutationAnalysisResult)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(egfrMutationAnalysisTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(ros1ByfishTest.PanelSetId) == true)
            {
                Test.ROS1ByFISH.ROS1ByFISHTestOrder ros1ByFISHTestOrder = (ROS1ByFISH.ROS1ByFISHTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(ros1ByfishTest.PanelSetId);
                if (ros1ByFISHTestOrder.Result != panelSetOrder.ROS1ByFISHResult)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(ros1ByFISHTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(alkTest.PanelSetId) == true)
            {
                Test.ALKForNSCLCByFISH.ALKForNSCLCByFISHTestOrder alkTestOrder = (ALKForNSCLCByFISH.ALKForNSCLCByFISHTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(alkTest.PanelSetId);
                if (alkTestOrder.Result != panelSetOrder.ALKForNSCLCByFISHResult)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(alkTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(brafTest.PanelSetId) == true)
            {
                Test.BRAFMutationAnalysis.BRAFMutationAnalysisTestOrder brafTestOrder = (BRAFMutationAnalysis.BRAFMutationAnalysisTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(brafTest.PanelSetId);
                if (brafTestOrder.Result != panelSetOrder.BRAFMutationAnalysisResult)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(brafTestOrder.PanelSetName);
                }
            }

            if (accessionOrder.PanelSetOrderCollection.Exists(pdl1SP142Test.PanelSetId) == true)
            {
                Test.PDL1SP142.PDL1SP142TestOrder pdl1SP142TestOrder = (PDL1SP142.PDL1SP142TestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(pdl1SP142Test.PanelSetId);
                if (pdl1SP142TestOrder.Result != panelSetOrder.PDL1SP142Result)
                {
                    result.Status   = Audit.Model.AuditStatusEnum.Warning;
                    result.Message += MismatchMessage(pdl1SP142TestOrder.PanelSetName);
                }
            }
        }
        private void DoesFinalSummaryResultMatch(AccessionOrder accessionOrder, string result, Audit.Model.AuditResult auditResult)
        {
            Business.Test.EGFRToALKReflexAnalysis.EGFRToALKReflexAnalysisTest egfrToALKReflexAnalysisTest = new EGFRToALKReflexAnalysis.EGFRToALKReflexAnalysisTest();

            if (accessionOrder.PanelSetOrderCollection.Exists(egfrToALKReflexAnalysisTest.PanelSetId) == true)
            {
                Business.Test.EGFRToALKReflexAnalysis.EGFRToALKReflexAnalysisTestOrder egfrToALKReflexAnalysisTestOrder = (EGFRToALKReflexAnalysis.EGFRToALKReflexAnalysisTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(egfrToALKReflexAnalysisTest.PanelSetId);
                egfrToALKReflexAnalysisTestOrder.DoesROS1ByFISHResultMatch(result, auditResult);
            }
        }
        public Audit.Model.AuditResult CheckFinaledUnsatResultWithAssociatedCases(YellowstonePathology.Business.Test.AccessionOrder accessionOrder)
        {
            Audit.Model.AuditResult result = new Audit.Model.AuditResult();
            result.Status = Audit.Model.AuditStatusEnum.OK;

            StringBuilder message = new StringBuilder();

            message.Append("The previously reported ");
            StringBuilder comment = new StringBuilder();

            comment.Append("Because the specimen is unsatisfactory for evaluation, the previously reported ");

            if (this.ScreeningType.ToUpper() == "FINAL RESULT" && Business.User.SystemIdentity.Instance.User.IsUserInRole(User.SystemUserRoleDescriptionEnum.Pathologist) == true)
            {
                if (YellowstonePathology.Business.Cytology.Model.CytologyResultCode.IsResultCodeUnsat(this.ResultCode) == true)
                {
                    bool hasHPVNeg   = false;
                    bool hasNGCTNeg  = false;
                    bool hasTrichNeg = false;

                    YellowstonePathology.Business.Test.HPV.HPVTest   panelSetHPV  = new YellowstonePathology.Business.Test.HPV.HPVTest();
                    YellowstonePathology.Business.Test.NGCT.NGCTTest panelSetNGCT = new YellowstonePathology.Business.Test.NGCT.NGCTTest();
                    YellowstonePathology.Business.Test.Trichomonas.TrichomonasTest panelSetTrichomonas = new YellowstonePathology.Business.Test.Trichomonas.TrichomonasTest();


                    if (accessionOrder.PanelSetOrderCollection.Exists(panelSetHPV.PanelSetId) == true)
                    {
                        YellowstonePathology.Business.Test.HPV.HPVTestOrder hpvTestOrder = (HPV.HPVTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(panelSetHPV.PanelSetId);
                        if (hpvTestOrder.Final == true && hpvTestOrder.Result == HPV.HPVResult.NegativeResult)
                        {
                            hasHPVNeg = true;
                            message.Append(panelSetHPV.PanelSetName);
                            comment.Append(panelSetHPV.PanelSetName + " (YPI report # " + hpvTestOrder.ReportNo + ")");
                        }
                    }
                    if (accessionOrder.PanelSetOrderCollection.Exists(panelSetNGCT.PanelSetId) == true)
                    {
                        YellowstonePathology.Business.Test.NGCT.NGCTTestOrder ngctTestOrder = (NGCT.NGCTTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(panelSetNGCT.PanelSetId);
                        if (ngctTestOrder.Final == true && ngctTestOrder.NGResultCode == NGCT.NGCTResult.NGNegativeResultCode && ngctTestOrder.CTResultCode == NGCT.NGCTResult.CTNegativeResultCode)
                        {
                            hasNGCTNeg = true;
                            if (hasHPVNeg == true)
                            {
                                message.Append(", ");
                                comment.Append(", ");
                            }
                            message.AppendLine(panelSetNGCT.PanelSetName);
                            comment.Append(panelSetNGCT.PanelSetName + " (YPI report # " + ngctTestOrder.ReportNo + ")");
                        }
                    }
                    if (accessionOrder.PanelSetOrderCollection.Exists(panelSetTrichomonas.PanelSetId) == true)
                    {
                        YellowstonePathology.Business.Test.Trichomonas.TrichomonasTestOrder trichTestOrder = (Trichomonas.TrichomonasTestOrder)accessionOrder.PanelSetOrderCollection.GetPanelSetOrder(panelSetTrichomonas.PanelSetId);
                        if (trichTestOrder.Final == true && trichTestOrder.ResultCode == "TRCHMNSNEG")
                        {
                            hasTrichNeg = true;
                            if (hasHPVNeg == true || hasNGCTNeg == true)
                            {
                                message.Append(", ");
                                comment.Append(", ");
                            }
                            message.AppendLine(panelSetTrichomonas.PanelSetName);
                            comment.Append(panelSetTrichomonas.PanelSetName + " (YPI report # " + trichTestOrder.ReportNo + ")");
                        }
                    }

                    if (hasHPVNeg || hasNGCTNeg || hasTrichNeg)
                    {
                        result.Status = Audit.Model.AuditStatusEnum.Failure;
                        if ((hasHPVNeg == true && (hasNGCTNeg == true || hasTrichNeg == true)) ||
                            (hasNGCTNeg == true && hasTrichNeg == true))
                        {
                            message.Append(" tests for this sample are NEGATIVE.  As the final Pap interpretation is UNSATIFACTORY, the results of the molecular ");
                            message.AppendLine("tests may not be accurate.  The following comment will be inserted in the report:");
                            comment.Append(" test results");
                        }
                        else
                        {
                            message.Append(" test for this sample is NEGATIVE.  As the final Pap interpretation is UNSATIFACTORY, the results of the molecular ");
                            message.AppendLine("test may not be accurate.  The following comment will be inserted in the report:");
                            comment.Append(" test result");
                        }

                        message.AppendLine();
                        message.Append("Comment: ");

                        comment.Append(" may not be reliable.  Repeat molecular analysis and/or Pap test may be warranted.  Recommend clinical correlation.");
                        message.AppendLine(comment.ToString());

                        if (string.IsNullOrEmpty(this.ReportComment) == false)
                        {
                            this.ReportComment += Environment.NewLine + Environment.NewLine;
                        }
                        this.ReportComment += comment.ToString();
                        result.Message      = message.ToString();
                    }
                }
            }
            return(result);
        }
Beispiel #31
0
        public virtual YellowstonePathology.Business.Audit.Model.AuditResult IsOkToFinalize(Test.AccessionOrder accessionOrder)
        {
            YellowstonePathology.Business.Audit.Model.AuditResult result = new Audit.Model.AuditResult();
            result.Status = Audit.Model.AuditStatusEnum.OK;

            YellowstonePathology.Business.Audit.Model.AuditCollection auditCollection = new Audit.Model.AuditCollection();
            auditCollection.Add(new Audit.Model.FinalizedAudit(this));
            auditCollection.Add(new Audit.Model.MRNAudit(accessionOrder));
            auditCollection.Add(new Audit.Model.AccountNoAudit(accessionOrder));
            auditCollection.Add(new Audit.Model.DistributionCanBeSetAudit(accessionOrder));
            result = auditCollection.Run2();

            return result;
        }