public void Build(SqlCommand cmd, YellowstonePathology.Business.Test.AccessionOrder accessionOrder)
        {
            XElement document = null;

            using (SqlConnection cn = new SqlConnection(YellowstonePathology.Business.Properties.Settings.Default.CurrentConnectionString))
            {
                cn.Open();
                cmd.Connection = cn;
                using (XmlReader xmlReader = cmd.ExecuteXmlReader())
                {
                    if (xmlReader.Read() == true)
                    {
                        document = XElement.Load(xmlReader, LoadOptions.PreserveWhitespace);
                    }
                }
            }

            if (document != null)
            {
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(document, accessionOrder);
                xmlPropertyWriter.Write();

                BuildSpecimenOrder(accessionOrder, document);
                BuildTaskOrder(accessionOrder, document);
                BuildIcdBillingCode(accessionOrder, document);
                BuildPanelSetOrder(accessionOrder, document);
            }
        }
        private void BuildPanelSetOrder(Test.AccessionOrder accessionOrder, XElement accessionOrderElement)
        {
            YellowstonePathology.Business.PanelSet.Model.PanelSetCollection panelSetCollection = YellowstonePathology.Business.PanelSet.Model.PanelSetCollection.GetAll();

            List <XElement> panelSetOrderElements = (from psoc in accessionOrderElement.Elements("PanelSetOrderCollection")
                                                     select psoc).ToList <XElement>();

            foreach (XElement panelSetOrderElement in panelSetOrderElements.Elements("PanelSetOrder"))
            {
                int    panelSetId = Convert.ToInt32(panelSetOrderElement.Element("PanelSetId").Value);
                string reportNo   = panelSetOrderElement.Element("ReportNo").Value;

                YellowstonePathology.Business.PanelSet.Model.PanelSet panelSet = panelSetCollection.GetPanelSet(panelSetId);
                Test.PanelSetOrder panelSetOrder = Test.PanelSetOrderFactory.CreatePanelSetOrder(panelSet);
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelSetOrderElement, panelSetOrder);
                xmlPropertyWriter.Write();

                YellowstonePathology.Business.Builder.PanelSetOrderBuilder builder = YellowstonePathology.Business.Builder.PanelSetOrderBuilderFactory.GetBuilder(panelSetId);
                builder.Build(panelSetOrder, panelSetOrderElement);
                this.SetOrderedOnDescription(panelSetOrder, accessionOrder);
                BuildAmendment(panelSetOrder, panelSetOrderElement);
                BuildPanelSetOrderCPTCode(panelSetOrder, panelSetOrderElement);
                BuildPanelSetOrderCPTCodeBill(panelSetOrder, panelSetOrderElement);
                BuildTestOrderReportDistribution(panelSetOrder, panelSetOrderElement);
                BuildTestOrderReportDistributionLog(panelSetOrder, panelSetOrderElement);
                BuildPanelOrder(panelSetOrder, panelSetOrderElement);
                BuildSurgicalSpecific(accessionOrder, panelSetOrder, panelSetOrderElement);
                accessionOrder.PanelSetOrderCollection.Add(panelSetOrder);
            }
        }
        private void BuildSurgicalSpecific(YellowstonePathology.Business.Test.AccessionOrder accessionOrder, YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            YellowstonePathology.Business.Test.Surgical.SurgicalTest panelSetSurgical = new YellowstonePathology.Business.Test.Surgical.SurgicalTest();
            if (panelSetOrder.PanelSetId == panelSetSurgical.PanelSetId)
            {
                YellowstonePathology.Business.Test.Surgical.SurgicalTestOrder panelSetOrderSurgical = (YellowstonePathology.Business.Test.Surgical.SurgicalTestOrder)panelSetOrder;
                List <XElement> surgicalSpecimenElements = (from item in panelSetOrderElement.Elements("SurgicalSpecimenCollection")
                                                            select item).ToList <XElement>();
                foreach (XElement surgicalSpecimenElement in surgicalSpecimenElements.Elements("SurgicalSpecimen"))
                {
                    YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen  = new YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen();
                    YellowstonePathology.Business.Persistence.XmlPropertyWriter  xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(surgicalSpecimenElement, surgicalSpecimen);
                    xmlPropertyWriter.Write();
                    BuildICD9Code(surgicalSpecimen, surgicalSpecimenElement);
                    BuildIntraoperativeConsultationResult(surgicalSpecimen, surgicalSpecimenElement);
                    BuildStainResult(surgicalSpecimen, surgicalSpecimenElement);
                    panelSetOrderSurgical.SurgicalSpecimenCollection.Add(surgicalSpecimen);
                }

                BuildSurgicalAudit(panelSetOrderSurgical, panelSetOrderElement);
                SetSurgicalAuditAmendment(panelSetOrderSurgical);
                SetSurgicalSpecimenSpecimenOrder(accessionOrder, panelSetOrderSurgical);
                SetSurgicalSpecimenAuditSpecimenOrder(accessionOrder, panelSetOrderSurgical);
                SetSurgicalSpecimenOrderItemCollection(accessionOrder, panelSetOrderSurgical);
            }
        }
        private void Build(YellowstonePathology.Business.Task.Model.TaskOrder taskOrder)
        {
            XElement documentElement = new XElement("Document");

            using (SqlConnection cn = new SqlConnection(Properties.Settings.Default.ProductionConnectionString))
            {
                cn.Open();
                this.m_SQLCommand.Connection = cn;
                using (XmlReader xmlReader = this.m_SQLCommand.ExecuteXmlReader())
                {
                    if (xmlReader.Read() == true)
                    {
                        documentElement = XElement.Load(xmlReader);
                    }
                }
            }

            YellowstonePathology.Business.Persistence.XmlPropertyWriter taskOrderWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(documentElement, taskOrder);
            taskOrderWriter.Write();

            List<XElement> taskOrderDetailElements = (from item in documentElement.Elements("TaskOrderDetailCollection") select item).ToList<XElement>();
            foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
            {
                YellowstonePathology.Business.Task.Model.TaskOrderDetail taskOrderDetail = new YellowstonePathology.Business.Task.Model.TaskOrderDetail();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter taskOrderDetailWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
                taskOrderDetailWriter.Write();
                taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
            }
        }
Example #5
0
        private void Build(YellowstonePathology.Business.Task.Model.TaskOrder taskOrder)
        {
            XElement documentElement = new XElement("Document");

            using (SqlConnection cn = new SqlConnection(Properties.Settings.Default.ProductionConnectionString))
            {
                cn.Open();
                this.m_SQLCommand.Connection = cn;
                using (XmlReader xmlReader = this.m_SQLCommand.ExecuteXmlReader())
                {
                    if (xmlReader.Read() == true)
                    {
                        documentElement = XElement.Load(xmlReader);
                    }
                }
            }

            YellowstonePathology.Business.Persistence.XmlPropertyWriter taskOrderWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(documentElement, taskOrder);
            taskOrderWriter.Write();

            List <XElement> taskOrderDetailElements = (from item in documentElement.Elements("TaskOrderDetailCollection") select item).ToList <XElement>();

            foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
            {
                YellowstonePathology.Business.Task.Model.TaskOrderDetail    taskOrderDetail       = new YellowstonePathology.Business.Task.Model.TaskOrderDetail();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter taskOrderDetailWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
                taskOrderDetailWriter.Write();
                taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
            }
        }
 public static YellowstonePathology.Business.Task.Model.TaskOrderDetail BuildTaskOrderDetail(XElement taskOrderDetailElement)
 {
     YellowstonePathology.Business.Task.Model.TaskOrderDetail taskOrderDetail = new YellowstonePathology.Business.Task.Model.TaskOrderDetail();
     YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
     xmlPropertyWriter.Write();
     return taskOrderDetail;
 }
        public void Build(SqlCommand cmd, YellowstonePathology.Business.Test.AccessionOrder accessionOrder)
        {
            XElement document = null;
            using (SqlConnection cn = new SqlConnection(YellowstonePathology.Business.Properties.Settings.Default.CurrentConnectionString))
            {
                cn.Open();
                cmd.Connection = cn;
                using (XmlReader xmlReader = cmd.ExecuteXmlReader())
                {
                    if (xmlReader.Read() == true)
                    {
                        document = XElement.Load(xmlReader, LoadOptions.PreserveWhitespace);
                    }
                }
            }

            if (document != null)
            {
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(document, accessionOrder);
                xmlPropertyWriter.Write();

                BuildSpecimenOrder(accessionOrder, document);
                BuildTaskOrder(accessionOrder, document);
                BuildIcdBillingCode(accessionOrder, document);
                BuildPanelSetOrder(accessionOrder, document);
            }
        }
        public override void Build(YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, System.Xml.Linq.XElement panelSetOrderElement)
        {
            Test.LLP.PanelSetOrderLeukemiaLymphoma llpPanelSetOrder = (Test.LLP.PanelSetOrderLeukemiaLymphoma)panelSetOrder;

            List<XElement> markerElements = (from item in panelSetOrderElement.Elements("FlowMarkerCollection")
                                             select item).ToList<XElement>();

            llpPanelSetOrder.FlowMarkerCollection.RemoveDeleted(markerElements.Elements("FlowMarker"));

            Flow.FlowMarkerItem flowMarker = null;
            foreach (XElement markerElement in markerElements.Elements("FlowMarker"))
            {
                string flowMarkerId = markerElement.Element("FlowMarkerId").Value;

                if (llpPanelSetOrder.FlowMarkerCollection.Exists(flowMarkerId) == true)
                {
                    flowMarker = llpPanelSetOrder.FlowMarkerCollection.Get(flowMarkerId);
                }
                else
                {
                    flowMarker = new Flow.FlowMarkerItem();
                    llpPanelSetOrder.FlowMarkerCollection.Add(flowMarker);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(markerElement, flowMarker);
                xmlPropertyWriter.Write();
            }
        }
Example #9
0
 private static Flow.FlowMarkerItem BuildFlowMarkerItem(XElement sourceElement)
 {
     Flow.FlowMarkerItem flowMarkerItem = new Flow.FlowMarkerItem();
     if (sourceElement != null)
     {
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(sourceElement, flowMarkerItem);
         xmlPropertyWriter.Write();
     }
     return(flowMarkerItem);
 }
Example #10
0
 private void BuildLocation(YellowstonePathology.Business.Client.Model.Client client, XElement clientElement)
 {
     List<XElement> clientLocationElements = (from item in clientElement.Elements("ClientLocationCollection")
                                                  select item).ToList<XElement>();
     foreach (XElement clientLocationElement in clientLocationElements.Elements("ClientLocation"))
     {
         YellowstonePathology.Business.Client.Model.ClientLocation clientLocation = new YellowstonePathology.Business.Client.Model.ClientLocation();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(clientLocationElement, clientLocation);
         xmlPropertyWriter.Write();
         client.ClientLocationCollection.Add(clientLocation);
     }
 }
 public override void Build(Test.PanelSetOrder panelSetOrder, System.Xml.Linq.XElement panelSetOrderElement)
 {
     List<XElement> markerElements = (from item in panelSetOrderElement.Elements("FlowMarkerCollection")
                                      select item).ToList<XElement>();
     foreach (XElement markerElement in markerElements.Elements("FlowMarker"))
     {
         Flow.FlowMarkerItem flowMarkerItem = new Flow.FlowMarkerItem();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(markerElement, flowMarkerItem);
         xmlPropertyWriter.Write();
         ((Test.LLP.PanelSetOrderLeukemiaLymphoma)panelSetOrder).FlowMarkerCollection.Add(flowMarkerItem);
     }
 }
Example #12
0
        public override void Build(Test.PanelSetOrder panelSetOrder, System.Xml.Linq.XElement panelSetOrderElement)
        {
            List <XElement> markerElements = (from item in panelSetOrderElement.Elements("FlowMarkerCollection")
                                              select item).ToList <XElement>();

            foreach (XElement markerElement in markerElements.Elements("FlowMarker"))
            {
                Flow.FlowMarkerItem flowMarkerItem = new Flow.FlowMarkerItem();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(markerElement, flowMarkerItem);
                xmlPropertyWriter.Write();
                ((Test.LLP.PanelSetOrderLeukemiaLymphoma)panelSetOrder).FlowMarkerCollection.Add(flowMarkerItem);
            }
        }
 public static YellowstonePathology.Business.Task.Model.TaskOrder BuildTaskOrder(XElement taskOrderElement)
 {
     YellowstonePathology.Business.Task.Model.TaskOrder taskOrder = new YellowstonePathology.Business.Task.Model.TaskOrder();
     YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderElement, taskOrder);
     xmlPropertyWriter.Write();
     List<XElement> taskOrderDetailElements = (from item in taskOrderElement.Elements("TaskOrderDetailCollection") select item).ToList<XElement>();
     foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
     {
         YellowstonePathology.Business.Task.Model.TaskOrderDetail taskOrderDetail = BuildTaskOrderDetail(taskOrderDetailElement);
         taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
     }
     return taskOrder;
 }
        private void BuildStainResult(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
        {
            List <XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("StainResultItemCollection")
                                                  select item).ToList <XElement>();

            foreach (XElement stainResultElement in collectionElements.Elements("StainResultItem"))
            {
                YellowstonePathology.Business.SpecialStain.StainResultItem  stainResultItem   = new SpecialStain.StainResultItem();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(stainResultElement, stainResultItem);
                xmlPropertyWriter.Write();
                surgicalSpecimen.StainResultItemCollection.Add(stainResultItem);
            }
        }
        private void BuildTestOrderReportDistributionLog(YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List <XElement> testOrderReportDistributionLogElements = (from item in panelSetOrderElement.Elements("TestOrderReportDistributionLogCollection")
                                                                      select item).ToList <XElement>();

            foreach (XElement testOrderReportDistributionLogElement in testOrderReportDistributionLogElements.Elements("TestOrderReportDistributionLog"))
            {
                YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog testOrderReportDistributionLog = new YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(testOrderReportDistributionLogElement, testOrderReportDistributionLog);
                xmlPropertyWriter.Write();
                panelSetOrder.TestOrderReportDistributionLogCollection.Add(testOrderReportDistributionLog);
            }
        }
        private void BuildSurgicalSpecimenAuditResult(YellowstonePathology.Business.Test.Surgical.SurgicalAudit surgicalAudit, XElement surgicalAuditElement)
        {
            List <XElement> collectionElements = (from item in surgicalAuditElement.Elements("SurgicalSpecimenAuditCollection")
                                                  select item).ToList <XElement>();

            foreach (XElement surgicalSpecimenResultAuditElement in collectionElements.Elements("SurgicalSpecimenAudit"))
            {
                YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit surgicalSpecimenAudit = new YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter       xmlPropertyWriter     = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(surgicalSpecimenResultAuditElement, surgicalSpecimenAudit);
                xmlPropertyWriter.Write();
                surgicalAudit.SurgicalSpecimenAuditCollection.Add(surgicalSpecimenAudit);
            }
        }
        private void BuildIcdBillingCode(Test.AccessionOrder accessionOrder, XElement accessionOrderElement)
        {
            List <XElement> icd9BillingCodeElements = (from item in accessionOrderElement.Elements("ICD9BillingCodeCollection")
                                                       select item).ToList <XElement>();

            foreach (XElement icd9BillingCodeElement in icd9BillingCodeElements.Elements("ICD9BillingCode"))
            {
                YellowstonePathology.Business.Billing.ICD9BillingCode       icd9BillingCode   = new Billing.ICD9BillingCode();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(icd9BillingCodeElement, icd9BillingCode);
                xmlPropertyWriter.Write();
                accessionOrder.ICD9BillingCodeCollection.Add(icd9BillingCode);
            }
        }
        private void BuildTaskOrderDetail(YellowstonePathology.Business.Task.Model.TaskOrder taskOrder, XElement taskOrderElement)
        {
            List <XElement> taskOrderDetailElements = (from item in taskOrderElement.Elements("TaskOrderDetailCollection")
                                                       select item).ToList <XElement>();

            foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
            {
                YellowstonePathology.Business.Task.Model.TaskOrderDetail    taskOrderDetail   = new YellowstonePathology.Business.Task.Model.TaskOrderDetail();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
                xmlPropertyWriter.Write();
                taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
            }
        }
        private void BuildPanelSetOrderCPTCodeBill(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List <XElement> panelSetOrderCPTCodeBillElements = (from item in panelSetOrderElement.Elements("PanelSetOrderCPTCodeBillCollection")
                                                                select item).ToList <XElement>();

            foreach (XElement panelSetOrderCPTCodeBillElement in panelSetOrderCPTCodeBillElements.Elements("PanelSetOrderCPTCodeBill"))
            {
                YellowstonePathology.Business.Test.PanelSetOrderCPTCodeBill panelSetOrderCPTCodeBill = new Test.PanelSetOrderCPTCodeBill();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter        = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelSetOrderCPTCodeBillElement, panelSetOrderCPTCodeBill);
                xmlPropertyWriter.Write();
                panelSetOrder.PanelSetOrderCPTCodeBillCollection.Add(panelSetOrderCPTCodeBill);
            }
        }
        private void BuildICD9Code(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
        {
            List <XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("ICD9BillingCodeCollection")
                                                  select item).ToList <XElement>();

            foreach (XElement icd9BillingElement in collectionElements.Elements("ICD9BillingCode"))
            {
                YellowstonePathology.Business.Billing.ICD9BillingCode       icd9Billing       = new YellowstonePathology.Business.Billing.ICD9BillingCode();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(icd9BillingElement, icd9Billing);
                xmlPropertyWriter.Write();
                surgicalSpecimen.ICD9BillingCodeCollection.Add(icd9Billing);
            }
        }
        private void BuildAmendment(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List <XElement> amendmentElements = (from item in panelSetOrderElement.Elements("AmendmentCollection")
                                                 select item).ToList <XElement>();

            foreach (XElement amendmentElement in amendmentElements.Elements("Amendment"))
            {
                YellowstonePathology.Business.Amendment.Model.Amendment     amendment         = new YellowstonePathology.Business.Amendment.Model.Amendment();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(amendmentElement, amendment);
                xmlPropertyWriter.Write();
                panelSetOrder.AmendmentCollection.Add(amendment);
            }
        }
        private void BuildAliquotOrderSlideOrderCollection(YellowstonePathology.Business.Test.AliquotOrder aliquotOrder, XElement aliquotOrderElement)
        {
            List <XElement> slideOrderElements = (from item in aliquotOrderElement.Elements("SlideOrderCollection")
                                                  select item).ToList <XElement>();

            foreach (XElement slideOrderElement in slideOrderElements.Elements("SlideOrder"))
            {
                YellowstonePathology.Business.Slide.Model.SlideOrder        slideOrder        = new YellowstonePathology.Business.Slide.Model.SlideOrder();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(slideOrderElement, slideOrder);
                xmlPropertyWriter.Write();
                aliquotOrder.SlideOrderCollection.Add(slideOrder);
            }
        }
        private void BuildIntraoperativeConsultationResult(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
        {
            List <XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("IntraoperativeConsultationResultCollection")
                                                  select item).ToList <XElement>();

            foreach (XElement intraoperativeConsultationResultElement in collectionElements.Elements("IntraoperativeConsultationResult"))
            {
                YellowstonePathology.Business.Test.Surgical.IntraoperativeConsultationResult intraoperativeConsultationResult = new YellowstonePathology.Business.Test.Surgical.IntraoperativeConsultationResult();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(intraoperativeConsultationResultElement, intraoperativeConsultationResult);
                xmlPropertyWriter.Write();
                surgicalSpecimen.IntraoperativeConsultationResultCollection.Add(intraoperativeConsultationResult);
            }
        }
Example #24
0
        private void BuildLocation(YellowstonePathology.Business.Client.Model.Client client, XElement clientElement)
        {
            List <XElement> clientLocationElements = (from item in clientElement.Elements("ClientLocationCollection")
                                                      select item).ToList <XElement>();

            foreach (XElement clientLocationElement in clientLocationElements.Elements("ClientLocation"))
            {
                YellowstonePathology.Business.Client.Model.ClientLocation   clientLocation    = new YellowstonePathology.Business.Client.Model.ClientLocation();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(clientLocationElement, clientLocation);
                xmlPropertyWriter.Write();
                client.ClientLocationCollection.Add(clientLocation);
            }
        }
 private void BuildClientSupplyOrderDetail(YellowstonePathology.Business.Client.Model.ClientSupplyOrder clientSupplyOrder, XElement clientSupplyOrderElement)
 {
     clientSupplyOrder.ClientSupplyOrderDetailCollection.Clear();
     List<XElement> clientSupplyOrderDetailElements = (from item in clientSupplyOrderElement.Elements("ClientSupplyOrderDetailCollection")
                                              select item).ToList<XElement>();
     foreach (XElement clientSupplyOrderDetailElement in clientSupplyOrderDetailElements.Elements("ClientSupplyOrderDetail"))
     {
         YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail clientSupplyOrderDetail = new YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(clientSupplyOrderDetailElement, clientSupplyOrderDetail);
         xmlPropertyWriter.Write();
         clientSupplyOrder.ClientSupplyOrderDetailCollection.Add(clientSupplyOrderDetail);
     }
 }
Example #26
0
        private void BuildClientSupplyOrderDetail(YellowstonePathology.Business.Client.Model.ClientSupplyOrder clientSupplyOrder, XElement clientSupplyOrderElement)
        {
            clientSupplyOrder.ClientSupplyOrderDetailCollection.Clear();
            List <XElement> clientSupplyOrderDetailElements = (from item in clientSupplyOrderElement.Elements("ClientSupplyOrderDetailCollection")
                                                               select item).ToList <XElement>();

            foreach (XElement clientSupplyOrderDetailElement in clientSupplyOrderDetailElements.Elements("ClientSupplyOrderDetail"))
            {
                YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail clientSupplyOrderDetail = new YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter        xmlPropertyWriter       = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(clientSupplyOrderDetailElement, clientSupplyOrderDetail);
                xmlPropertyWriter.Write();
                clientSupplyOrder.ClientSupplyOrderDetailCollection.Add(clientSupplyOrderDetail);
            }
        }
Example #27
0
 public void Build(XElement testElement)
 {
     if (testElement != null)
     {
         YellowstonePathology.Business.Test.Model.Test test = new YellowstonePathology.Business.Test.Model.Test();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(testElement, test);
         xmlPropertyWriter.Write();
         this.BuildResultItemCollection(test, testElement);
         this.m_Test = test;
     }
     else
     {
         this.m_Test = null;
     }
 }
Example #28
0
 public void Build(XElement testElement)
 {
     if (testElement != null)
     {
         YellowstonePathology.Business.Test.Model.Test test = new YellowstonePathology.Business.Test.Model.Test();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(testElement, test);
         xmlPropertyWriter.Write();
         this.BuildResultItemCollection(test, testElement);
         this.m_Test = test;
     }
     else
     {
         this.m_Test = null;
     }
 }
        public static Test.PanelOrder BuildPanelOrder(XElement panelOrderElement)
        {
            YellowstonePathology.Business.Panel.Model.PanelCollection panelCollection = YellowstonePathology.Business.Panel.Model.PanelCollection.GetAll();
            int panelId = Convert.ToInt32(panelOrderElement.Element("PanelId").Value);
            YellowstonePathology.Business.Panel.Model.Panel panel = panelCollection.GetPanel(panelId);
            Test.PanelOrder panelOrder = Test.PanelOrderFactory.GetPanelOrder(panel);

            YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelOrderElement, panelOrder);
            xmlPropertyWriter.Write();
            List<XElement> testOrderElements = (from item in panelOrderElement.Elements("TestOrderCollection") select item).ToList<XElement>();
            foreach (XElement testOrderElement in testOrderElements.Elements("TestOrder"))
            {
                YellowstonePathology.Business.Test.Model.TestOrder testOrder = BuildTestOrder(testOrderElement);
                panelOrder.TestOrderCollection.Add(testOrder);
            }
            return panelOrder;
        }
        private void BuildPanelOrder(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List <XElement> panelOrderElements = (from poc in panelSetOrderElement.Elements("PanelOrderCollection")
                                                  select poc).ToList <XElement>();

            YellowstonePathology.Business.Panel.Model.PanelCollection panelCollection = YellowstonePathology.Business.Panel.Model.PanelCollection.GetAll();


            foreach (XElement panelOrderElement in panelOrderElements.Elements("PanelOrder"))
            {
                int panelId = Convert.ToInt32(panelOrderElement.Element("PanelId").Value);
                YellowstonePathology.Business.Panel.Model.Panel panel = panelCollection.GetPanel(panelId);
                Test.PanelOrder panelOrder = Test.PanelOrderFactory.GetPanelOrder(panel);

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelOrderElement, panelOrder);
                xmlPropertyWriter.Write();
                BuildTestOrderRightSide(panelOrder, panelOrderElement);
                panelSetOrder.PanelOrderCollection.Add(panelOrder);
            }
        }
Example #31
0
        public static YellowstonePathology.Business.Test.AliquotOrderCollection GetAliquotOrderCollectionByReportNo(string reportNo)
        {
            YellowstonePathology.Business.Test.AliquotOrderCollection result = new Test.AliquotOrderCollection();
            SqlCommand cmd = new SqlCommand();

            cmd.CommandText = "gwGetAliquotOrderCollectionByReportNo";
            cmd.CommandType = System.Data.CommandType.StoredProcedure;
            cmd.Parameters.Add("@ReportNo", System.Data.SqlDbType.VarChar).Value = reportNo;

            XElement collectionElement = YellowstonePathology.Business.Domain.Persistence.SqlXmlPersistence.CrudOperations.ExecuteCommand(cmd, Domain.Persistence.DataLocationEnum.ProductionData);

            if (collectionElement != null)
            {
                List <XElement> aliquotElements = (from item in collectionElement.Elements("AliquotOrder") select item).ToList <XElement>();
                foreach (XElement aliquotElement in aliquotElements)
                {
                    YellowstonePathology.Business.Test.AliquotOrder             aliquotOrder      = new Test.AliquotOrder();
                    YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(aliquotElement, aliquotOrder);
                    xmlPropertyWriter.Write();
                    result.Add(aliquotOrder);
                }
            }
            return(result);
        }
        private void BuildPanelSetOrder(Test.AccessionOrder accessionOrder, XElement accessionOrderElement)
        {
            YellowstonePathology.Business.PanelSet.Model.PanelSetCollection panelSetCollection = YellowstonePathology.Business.PanelSet.Model.PanelSetCollection.GetAll();

            List<XElement> panelSetOrderElements = (from psoc in accessionOrderElement.Elements("PanelSetOrderCollection")
                                                        select psoc).ToList<XElement>();
            foreach (XElement panelSetOrderElement in panelSetOrderElements.Elements("PanelSetOrder"))
            {
                int panelSetId = Convert.ToInt32(panelSetOrderElement.Element("PanelSetId").Value);
                string reportNo = panelSetOrderElement.Element("ReportNo").Value;

                YellowstonePathology.Business.PanelSet.Model.PanelSet panelSet = panelSetCollection.GetPanelSet(panelSetId);
                Test.PanelSetOrder panelSetOrder = Test.PanelSetOrderFactory.CreatePanelSetOrder(panelSet);
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelSetOrderElement, panelSetOrder);
                xmlPropertyWriter.Write();

                YellowstonePathology.Business.Builder.PanelSetOrderBuilder builder = YellowstonePathology.Business.Builder.PanelSetOrderBuilderFactory.GetBuilder(panelSetId);
                builder.Build(panelSetOrder, panelSetOrderElement);
                this.SetOrderedOnDescription(panelSetOrder, accessionOrder);
                BuildAmendment(panelSetOrder, panelSetOrderElement);
                BuildPanelSetOrderCPTCode(panelSetOrder, panelSetOrderElement);
                BuildPanelSetOrderCPTCodeBill(panelSetOrder, panelSetOrderElement);
                BuildTestOrderReportDistribution(panelSetOrder, panelSetOrderElement);
                BuildTestOrderReportDistributionLog(panelSetOrder, panelSetOrderElement);
                BuildPanelOrder(panelSetOrder, panelSetOrderElement);
                BuildSurgicalSpecific(accessionOrder, panelSetOrder, panelSetOrderElement);
                accessionOrder.PanelSetOrderCollection.Add(panelSetOrder);
            }
        }
        private void BuildPanelOrder(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List<XElement> panelOrderElements = (from poc in panelSetOrderElement.Elements("PanelOrderCollection")
                                                 select poc).ToList<XElement>();

            YellowstonePathology.Business.Panel.Model.PanelCollection panelCollection = YellowstonePathology.Business.Panel.Model.PanelCollection.GetAll();

            foreach (XElement panelOrderElement in panelOrderElements.Elements("PanelOrder"))
            {
                int panelId = Convert.ToInt32(panelOrderElement.Element("PanelId").Value);
                YellowstonePathology.Business.Panel.Model.Panel panel = panelCollection.GetPanel(panelId);
                Test.PanelOrder panelOrder = Test.PanelOrderFactory.GetPanelOrder(panel);

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelOrderElement, panelOrder);
                xmlPropertyWriter.Write();
                BuildTestOrderRightSide(panelOrder, panelOrderElement);
                panelSetOrder.PanelOrderCollection.Add(panelOrder);
            }
        }
 private void BuildIntraoperativeConsultationResult(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
 {
     List<XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("IntraoperativeConsultationResultCollection")
                                          select item).ToList<XElement>();
     foreach (XElement intraoperativeConsultationResultElement in collectionElements.Elements("IntraoperativeConsultationResult"))
     {
         YellowstonePathology.Business.Test.Surgical.IntraoperativeConsultationResult intraoperativeConsultationResult = new YellowstonePathology.Business.Test.Surgical.IntraoperativeConsultationResult();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(intraoperativeConsultationResultElement, intraoperativeConsultationResult);
         xmlPropertyWriter.Write();
         surgicalSpecimen.IntraoperativeConsultationResultCollection.Add(intraoperativeConsultationResult);
     }
 }
 private void BuildIcdBillingCode(Test.AccessionOrder accessionOrder, XElement accessionOrderElement)
 {
     List<XElement> icd9BillingCodeElements = (from item in accessionOrderElement.Elements("ICD9BillingCodeCollection")
                                              select item).ToList<XElement>();
     foreach (XElement icd9BillingCodeElement in icd9BillingCodeElements.Elements("ICD9BillingCode"))
     {
         YellowstonePathology.Business.Billing.ICD9BillingCode icd9BillingCode = new Billing.ICD9BillingCode();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(icd9BillingCodeElement, icd9BillingCode);
         xmlPropertyWriter.Write();
         accessionOrder.ICD9BillingCodeCollection.Add(icd9BillingCode);
     }
 }
 private void BuildICD9Code(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
 {
     List<XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("ICD9BillingCodeCollection")
                                          select item).ToList<XElement>();
     foreach (XElement icd9BillingElement in collectionElements.Elements("ICD9BillingCode"))
     {
         YellowstonePathology.Business.Billing.ICD9BillingCode icd9Billing = new YellowstonePathology.Business.Billing.ICD9BillingCode();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(icd9BillingElement, icd9Billing);
         xmlPropertyWriter.Write();
         surgicalSpecimen.ICD9BillingCodeCollection.Add(icd9Billing);
     }
 }
 private void BuildAmendment(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
 {
     List<XElement> amendmentElements = (from item in panelSetOrderElement.Elements("AmendmentCollection")
                                          select item).ToList<XElement>();
     foreach (XElement amendmentElement in amendmentElements.Elements("Amendment"))
     {
         YellowstonePathology.Business.Amendment.Model.Amendment amendment = new YellowstonePathology.Business.Amendment.Model.Amendment();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(amendmentElement, amendment);
         xmlPropertyWriter.Write();
         panelSetOrder.AmendmentCollection.Add(amendment);
     }
 }
        private void BuildTestOrderReportDistributionLog(YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            List<XElement> testOrderReportDistributionLogElements = (from item in panelSetOrderElement.Elements("TestOrderReportDistributionLogCollection")
                                                                      select item).ToList<XElement>();

            panelSetOrder.TestOrderReportDistributionLogCollection.RemoveDeleted(testOrderReportDistributionLogElements.Elements("TestOrderReportDistributionLog"));
            foreach (XElement testOrderReportDistributionLogElement in testOrderReportDistributionLogElements.Elements("TestOrderReportDistributionLog"))
            {
                string testOrderReportDistributionLogId = testOrderReportDistributionLogElement.Element("TestOrderReportDistributionLogId").Value;
                YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog testOrderReportDistributionLog = null;
                if (panelSetOrder.TestOrderReportDistributionLogCollection.Exists(testOrderReportDistributionLogId) == true)
                {
                    testOrderReportDistributionLog = panelSetOrder.TestOrderReportDistributionLogCollection.Get(testOrderReportDistributionLogId);
                }
                else
                {
                    testOrderReportDistributionLog = new YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog();
                    panelSetOrder.TestOrderReportDistributionLogCollection.Add(testOrderReportDistributionLog);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(testOrderReportDistributionLogElement, testOrderReportDistributionLog);
                xmlPropertyWriter.Write();
            }
        }
        private static YellowstonePathology.Business.Client.Model.ClientSupplyOrder BuildClientSupplyOrder(XElement sourceElement)
        {
            YellowstonePathology.Business.Client.Model.ClientSupplyOrder clientSupplyOrder = new Client.Model.ClientSupplyOrder();
            YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new Persistence.XmlPropertyWriter(sourceElement, clientSupplyOrder);
            xmlPropertyWriter.Write();

            List<XElement> clientSupplyOrderDetailElements = (from item in sourceElement.Elements("ClientSupplyOrderDetailCollection")
                                                            select item).ToList<XElement>();
            foreach (XElement clientSupplyOrderDetailElement in clientSupplyOrderDetailElements.Elements("ClientSupplyOrderDetail"))
            {
                YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail clientSupplyOrderDetail = new YellowstonePathology.Business.Client.Model.ClientSupplyOrderDetail();
                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriterDetail = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(clientSupplyOrderDetailElement, clientSupplyOrderDetail);
                xmlPropertyWriterDetail.Write();
                clientSupplyOrder.ClientSupplyOrderDetailCollection.Add(clientSupplyOrderDetail);
            }
            return clientSupplyOrder;
        }
 private void BuildStainResult(YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen, XElement surgicalSpecimenElement)
 {
     List<XElement> collectionElements = (from item in surgicalSpecimenElement.Elements("StainResultItemCollection")
                                          select item).ToList<XElement>();
     foreach (XElement stainResultElement in collectionElements.Elements("StainResultItem"))
     {
         YellowstonePathology.Business.SpecialStain.StainResultItem stainResultItem = new SpecialStain.StainResultItem();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(stainResultElement, stainResultItem);
         xmlPropertyWriter.Write();
         surgicalSpecimen.StainResultItemCollection.Add(stainResultItem);
     }
 }
Example #41
0
 private static Flow.FlowMarkerItem BuildFlowMarkerItem(XElement sourceElement)
 {
     Flow.FlowMarkerItem flowMarkerItem = new Flow.FlowMarkerItem();
     if (sourceElement != null)
     {
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(sourceElement, flowMarkerItem);
         xmlPropertyWriter.Write();
     }
     return flowMarkerItem;
 }
 private void BuildSurgicalSpecimenAuditResult(YellowstonePathology.Business.Test.Surgical.SurgicalAudit surgicalAudit, XElement surgicalAuditElement)
 {
     List<XElement> collectionElements = (from item in surgicalAuditElement.Elements("SurgicalSpecimenAuditCollection")
                                          select item).ToList<XElement>();
     foreach (XElement surgicalSpecimenResultAuditElement in collectionElements.Elements("SurgicalSpecimenAudit"))
     {
         YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit surgicalSpecimenAudit = new YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(surgicalSpecimenResultAuditElement, surgicalSpecimenAudit);
         xmlPropertyWriter.Write();
         surgicalAudit.SurgicalSpecimenAuditCollection.Add(surgicalSpecimenAudit);
     }
 }
 private void BuildTestOrderReportDistributionLog(YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
 {
     List<XElement> testOrderReportDistributionLogElements = (from item in panelSetOrderElement.Elements("TestOrderReportDistributionLogCollection")
                                                               select item).ToList<XElement>();
     foreach (XElement testOrderReportDistributionLogElement in testOrderReportDistributionLogElements.Elements("TestOrderReportDistributionLog"))
     {
         YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog testOrderReportDistributionLog = new YellowstonePathology.Business.ReportDistribution.Model.TestOrderReportDistributionLog();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(testOrderReportDistributionLogElement, testOrderReportDistributionLog);
         xmlPropertyWriter.Write();
         panelSetOrder.TestOrderReportDistributionLogCollection.Add(testOrderReportDistributionLog);
     }
 }
 private void BuildPanelSetOrderCPTCodeBill(Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
 {
     List<XElement> panelSetOrderCPTCodeBillElements = (from item in panelSetOrderElement.Elements("PanelSetOrderCPTCodeBillCollection")
                                                    select item).ToList<XElement>();
     foreach (XElement panelSetOrderCPTCodeBillElement in panelSetOrderCPTCodeBillElements.Elements("PanelSetOrderCPTCodeBill"))
     {
         YellowstonePathology.Business.Test.PanelSetOrderCPTCodeBill panelSetOrderCPTCodeBill = new Test.PanelSetOrderCPTCodeBill();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(panelSetOrderCPTCodeBillElement, panelSetOrderCPTCodeBill);
         xmlPropertyWriter.Write();
         panelSetOrder.PanelSetOrderCPTCodeBillCollection.Add(panelSetOrderCPTCodeBill);
     }
 }
        private void BuildTestOrderSlideOrderCollection(YellowstonePathology.Business.Test.Model.TestOrder testOrder, XElement testOrderElement)
        {
            List<XElement> slideOrderElements = (from item in testOrderElement.Elements("SlideOrderCollection")
                                                           select item).ToList<XElement>();

            testOrder.SlideOrderCollection.RemoveDeleted(slideOrderElements.Elements("SlideOrder"));
            foreach (XElement slideOrderElement in slideOrderElements.Elements("SlideOrder"))
            {
                string slideOrderId = slideOrderElement.Element("SlideOrderId").Value;
                YellowstonePathology.Business.Slide.Model.SlideOrder slideOrder = new YellowstonePathology.Business.Slide.Model.SlideOrder();
                if (testOrder.SlideOrderCollection.Exists(slideOrderId) == true)
                {
                    slideOrder = testOrder.SlideOrderCollection.Get(slideOrderId);
                }
                else
                {
                    slideOrder = new YellowstonePathology.Business.Slide.Model.SlideOrder();
                    testOrder.SlideOrderCollection.Add(slideOrder);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(slideOrderElement, slideOrder);
                xmlPropertyWriter.Write();
            }
        }
        private void BuildSurgicalSpecific(YellowstonePathology.Business.Test.AccessionOrder accessionOrder, YellowstonePathology.Business.Test.PanelSetOrder panelSetOrder, XElement panelSetOrderElement)
        {
            YellowstonePathology.Business.Test.Surgical.SurgicalTest panelSetSurgical = new YellowstonePathology.Business.Test.Surgical.SurgicalTest();
            if (panelSetOrder.PanelSetId == panelSetSurgical.PanelSetId)
            {
                YellowstonePathology.Business.Test.Surgical.SurgicalTestOrder panelSetOrderSurgical = (YellowstonePathology.Business.Test.Surgical.SurgicalTestOrder)panelSetOrder;
                List<XElement> surgicalSpecimenElements = (from item in panelSetOrderElement.Elements("SurgicalSpecimenCollection")
                                                                     select item).ToList<XElement>();
                foreach (XElement surgicalSpecimenElement in surgicalSpecimenElements.Elements("SurgicalSpecimen"))
                {
                    YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen surgicalSpecimen = new YellowstonePathology.Business.Test.Surgical.SurgicalSpecimen();
                    YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(surgicalSpecimenElement, surgicalSpecimen);
                    xmlPropertyWriter.Write();
                    BuildICD9Code(surgicalSpecimen, surgicalSpecimenElement);
                    BuildIntraoperativeConsultationResult(surgicalSpecimen, surgicalSpecimenElement);
                    BuildStainResult(surgicalSpecimen, surgicalSpecimenElement);
                    panelSetOrderSurgical.SurgicalSpecimenCollection.Add(surgicalSpecimen);
                }

                BuildSurgicalAudit(panelSetOrderSurgical, panelSetOrderElement);
                SetSurgicalAuditAmendment(panelSetOrderSurgical);
                SetSurgicalSpecimenSpecimenOrder(accessionOrder, panelSetOrderSurgical);
                SetSurgicalSpecimenAuditSpecimenOrder(accessionOrder, panelSetOrderSurgical);
                SetSurgicalSpecimenOrderItemCollection(accessionOrder, panelSetOrderSurgical);
            }
        }
        private void BuildSurgicalSpecimenAuditResult(YellowstonePathology.Business.Test.Surgical.SurgicalAudit surgicalAudit, XElement surgicalAuditElement)
        {
            List<XElement> collectionElements = (from item in surgicalAuditElement.Elements("SurgicalSpecimenAuditCollection")
                                                 select item).ToList<XElement>();

            surgicalAudit.SurgicalSpecimenAuditCollection.RemoveDeleted(collectionElements.Elements("SurgicalSpecimenAudit"));
            foreach (XElement surgicalSpecimenResultAuditElement in collectionElements.Elements("SurgicalSpecimenAudit"))
            {
                string surgicalSpecimenAuditId = surgicalSpecimenResultAuditElement.Element("SurgicalSpecimenAuditId").Value;
                YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit surgicalSpecimenAudit = null;
                if (surgicalAudit.SurgicalSpecimenAuditCollection.Exists(surgicalSpecimenAuditId) == true)
                {
                    surgicalSpecimenAudit = surgicalAudit.SurgicalSpecimenAuditCollection.Get(surgicalSpecimenAuditId);
                }
                else
                {
                    surgicalSpecimenAudit = new YellowstonePathology.Business.Test.Surgical.SurgicalSpecimenAudit();
                    surgicalAudit.SurgicalSpecimenAuditCollection.Add(surgicalSpecimenAudit);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(surgicalSpecimenResultAuditElement, surgicalSpecimenAudit);
                xmlPropertyWriter.Write();
            }
        }
 private void BuildTaskOrderDetail(YellowstonePathology.Business.Task.Model.TaskOrder taskOrder, XElement taskOrderElement)
 {
     List<XElement> taskOrderDetailElements = (from item in taskOrderElement.Elements("TaskOrderDetailCollection")
                                         select item).ToList<XElement>();
     foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
     {
         YellowstonePathology.Business.Task.Model.TaskOrderDetail taskOrderDetail = new YellowstonePathology.Business.Task.Model.TaskOrderDetail();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
         xmlPropertyWriter.Write();
         taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
     }
 }
        private void BuildTaskOrder(Test.AccessionOrder accessionOrder, XElement accessionOrderElement)
        {
            List<XElement> taskOrderElements = (from item in accessionOrderElement.Elements("TaskOrderCollection")
                                                         select item).ToList<XElement>();

            accessionOrder.TaskOrderCollection.RemoveDeleted(taskOrderElements.Elements("TaskOrder"));
            foreach (XElement taskOrderElement in taskOrderElements.Elements("TaskOrder"))
            {
                string taskOrderId = taskOrderElement.Element("TaskOrderId").Value;
                YellowstonePathology.Business.Task.Model.TaskOrder taskOrder = null;

                if (accessionOrder.TaskOrderCollection.Exists(taskOrderId) == true)
                {
                    taskOrder = accessionOrder.TaskOrderCollection.GetTaskOrder(taskOrderId);
                }
                else
                {
                    taskOrder = new YellowstonePathology.Business.Task.Model.TaskOrder();
                    accessionOrder.TaskOrderCollection.Add(taskOrder);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderElement, taskOrder);
                xmlPropertyWriter.Write();
                this.BuildTaskOrderDetail(taskOrder, taskOrderElement);
            }
        }
 private void BuildTestOrderSlideOrderCollection(YellowstonePathology.Business.Test.Model.TestOrder testOrder, XElement testOrderElement)
 {
     List<XElement> slideOrderElements = (from item in testOrderElement.Elements("SlideOrderCollection")
                                                    select item).ToList<XElement>();
     foreach (XElement slideOrderElement in slideOrderElements.Elements("SlideOrder"))
     {
         YellowstonePathology.Business.Slide.Model.SlideOrder slideOrder = new YellowstonePathology.Business.Slide.Model.SlideOrder();
         YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(slideOrderElement, slideOrder);
         xmlPropertyWriter.Write();
         testOrder.SlideOrderCollection.Add(slideOrder);
     }
 }
        private void BuildTaskOrderDetail(YellowstonePathology.Business.Task.Model.TaskOrder taskOrder, XElement taskOrderElement)
        {
            List<XElement> taskOrderDetailElements = (from item in taskOrderElement.Elements("TaskOrderDetailCollection")
                                                select item).ToList<XElement>();
            taskOrder.TaskOrderDetailCollection.RemoveDeleted(taskOrderDetailElements.Elements("TaskOrderDetail"));
            foreach (XElement taskOrderDetailElement in taskOrderDetailElements.Elements("TaskOrderDetail"))
            {
                string taskOrderDetailId = taskOrderDetailElement.Element("TaskOrderDetailId").Value;
                YellowstonePathology.Business.Task.Model.TaskOrderDetail taskOrderDetail = null;
                if (taskOrder.TaskOrderDetailCollection.Exists(taskOrderDetailId) == true)
                {
                    taskOrderDetail = taskOrder.TaskOrderDetailCollection.Get(taskOrderDetailId);
                }
                else
                {
                    string taskId = taskOrderDetailElement.Element("TaskId").Value;
                    taskOrderDetail = YellowstonePathology.Business.Task.Model.TaskOrderDetailFactory.GetTaskOrderDetail(taskId);
                    taskOrder.TaskOrderDetailCollection.Add(taskOrderDetail);
                }

                YellowstonePathology.Business.Persistence.XmlPropertyWriter xmlPropertyWriter = new YellowstonePathology.Business.Persistence.XmlPropertyWriter(taskOrderDetailElement, taskOrderDetail);
                xmlPropertyWriter.Write();
            }
        }