public void Sync(DataTable dataTable, string reportNo)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string testOrderReportDistributionLogId = dataTableReader["TestOrderReportDistributionLogId"].ToString();
                string distributionReportNo             = dataTableReader["ReportNo"].ToString();

                TestOrderReportDistributionLog testOrderReportDistributionLog = null;

                if (this.Exists(testOrderReportDistributionLogId) == true)
                {
                    testOrderReportDistributionLog = this.Get(testOrderReportDistributionLogId);
                }
                else if (reportNo == distributionReportNo)
                {
                    testOrderReportDistributionLog = new TestOrderReportDistributionLog();
                    this.Add(testOrderReportDistributionLog);
                }

                if (testOrderReportDistributionLog != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(testOrderReportDistributionLog, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #2
0
        public void SyncAliquot(DataTable dataTable, string aliquotOrderId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string testOrderId        = dataTableReader["TestOrderId"].ToString();
                string testAliquotOrderId = dataTableReader["AliquotOrderId"].ToString();

                TestOrder testOrder = null;

                if (this.ExistsByTestOrderId(testOrderId) == true)
                {
                    testOrder = this.GetTestOrder(testOrderId);
                }
                else if (testAliquotOrderId == aliquotOrderId)
                {
                    testOrder = new TestOrder();
                    this.Add(testOrder);
                }

                if (testOrder != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(testOrder, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #3
0
        public void Sync(DataTable dataTable, string reportNo)
        {
            //this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string panelOrderId  = dataTableReader["PanelOrderId"].ToString();
                string panelReportNo = dataTableReader["ReportNo"].ToString();

                PanelOrder panelOrder = null;

                if (this.Exists(panelOrderId) == true)
                {
                    panelOrder = this.GetByPanelOrderId(panelOrderId);
                }
                else if (panelReportNo == reportNo)
                {
                    int panelId             = (int)dataTableReader["PanelId"];
                    Panel.Model.Panel panel = Panel.Model.PanelCollection.GetAll().GetPanel(panelId);
                    panelOrder = Test.PanelOrderFactory.GetPanelOrder(panel);
                    this.Add(panelOrder);
                }

                if (panelOrder != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(panelOrder, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #4
0
        public void Sync(DataTable dataTable, string reportNo)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string flowMarkerId   = dataTableReader["FlowMarkerId"].ToString();
                string markerReportNo = dataTableReader["ReportNo"].ToString();

                FlowMarkerItem flowMarkerItem = null;

                if (this.Exists(flowMarkerId) == true)
                {
                    flowMarkerItem = this.Get(flowMarkerId);
                }
                else if (reportNo == markerReportNo)
                {
                    flowMarkerItem = new FlowMarkerItem();
                    this.Add(flowMarkerItem);
                }

                if (flowMarkerItem != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(flowMarkerItem, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
        public void Sync(DataTable dataTable, string surgicalSpecimenId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string icd9BillingId          = dataTableReader["Icd9BillingId"].ToString();
                string icd9SurgicalSpecimenId = dataTableReader["SurgicalSpecimenId"].ToString();

                ICD9BillingCode icd9BillingCode = null;

                if (this.Exists(icd9BillingId) == true)
                {
                    icd9BillingCode = this.Get(icd9BillingId);
                }
                else if (surgicalSpecimenId == icd9SurgicalSpecimenId)
                {
                    icd9BillingCode = new ICD9BillingCode();
                    this.Add(icd9BillingCode);
                }

                if (icd9BillingCode != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(icd9BillingCode, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #6
0
        public void Sync(DataTable dataTable, string surgicalSpecimenId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string icd9BillingId        = dataTableReader["IntraoperativeConsultationResultId"].ToString();
                string icSurgicalSpecimenId = dataTableReader["SurgicalSpecimenId"].ToString();

                IntraoperativeConsultationResult intraoperativeConsultationResult = null;

                if (this.Exists(icd9BillingId) == true)
                {
                    intraoperativeConsultationResult = this.Get(icd9BillingId);
                }
                else if (surgicalSpecimenId == icSurgicalSpecimenId)
                {
                    intraoperativeConsultationResult = new IntraoperativeConsultationResult();
                    this.Add(intraoperativeConsultationResult);
                }

                if (intraoperativeConsultationResult != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(intraoperativeConsultationResult, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #7
0
        public void SyncForTestOrder(DataTable dataTable, string testOrderId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string slideOrderId     = dataTableReader["SlideOrderId"].ToString();
                string slideTestOrderId = dataTableReader["TestOrderId"].ToString();

                SlideOrder slideOrder = null;

                if (this.Exists(slideOrderId) == true)
                {
                    slideOrder = this.Get(slideOrderId);
                }
                else if (slideTestOrderId == testOrderId)
                {
                    slideOrder = new SlideOrder();
                    this.Add(slideOrder);
                }

                if (slideOrder != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(slideOrder, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #8
0
        public override void Sync(DataTable dataTable, string panelOrderId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);
            while (dataTableReader.Read())
            {
                string testOrderId = dataTableReader["TestOrderId"].ToString();
                string testPanelOrderId = dataTableReader["PanelOrderId"].ToString();

                TestOrder testOrder = null;

                if (this.Exists(testOrderId) == true)
                {
                    testOrder = this.Get(testOrderId);
                }
                else if (testPanelOrderId == panelOrderId)
                {
                    testOrder = new TestOrder();
                    this.Add(testOrder);
                }

                if (testOrder != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(testOrder, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #9
0
        public void Sync(DataTable dataTable)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string taskOrderId = dataTableReader["TaskOrderId"].ToString();

                TaskOrder taskOrder = null;

                if (this.Exists(taskOrderId) == true)
                {
                    taskOrder = this.GetTaskOrder(taskOrderId);
                }
                else
                {
                    taskOrder = new TaskOrder();
                    this.Add(taskOrder);
                }

                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(taskOrder, dataTableReader);
                sqlDataTableReaderPropertyWriter.WriteProperties();
            }
        }
Пример #10
0
        private void HandleSlideOrderTestOrder(DataTable dataTable)
        {
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string testOrderId = dataTableReader["TestOrderId"].ToString();
                YellowstonePathology.Business.Test.Model.TestOrder_Base testOrder = null;
                foreach (Business.Specimen.Model.SpecimenOrder specimenOrder in this.m_AccessionOrder.SpecimenOrderCollection)
                {
                    foreach (Business.Test.AliquotOrder aliquotOrder in specimenOrder.AliquotOrderCollection)
                    {
                        foreach (Business.Slide.Model.SlideOrder slideOrder in aliquotOrder.SlideOrderCollection)
                        {
                            if (slideOrder.TestOrderId == testOrderId)
                            {
                                if (slideOrder.TestOrder == null)
                                {
                                    testOrder            = new Test.Model.TestOrder();
                                    slideOrder.TestOrder = testOrder;
                                }
                                else
                                {
                                    testOrder = slideOrder.TestOrder;
                                }

                                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(testOrder, dataTableReader);
                                sqlDataTableReaderPropertyWriter.WriteProperties();
                            }
                        }
                    }
                }
            }
        }
Пример #11
0
        private void HandleTestOrderAliquotOrder(DataTable dataTable)
        {
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string aliquotOrderId = dataTableReader["AliquotOrderId"].ToString();
                YellowstonePathology.Business.Test.AliquotOrder_Base aliquotOrder = null;
                foreach (Business.Test.PanelSetOrder panelSetOrder in this.m_AccessionOrder.PanelSetOrderCollection)
                {
                    foreach (Business.Test.PanelOrder panelOrder in panelSetOrder.PanelOrderCollection)
                    {
                        foreach (Business.Test.Model.TestOrder testOrder in panelOrder.TestOrderCollection)
                        {
                            if (testOrder.AliquotOrderId == aliquotOrderId)
                            {
                                if (testOrder.AliquotOrder == null)
                                {
                                    aliquotOrder           = new Test.AliquotOrder();
                                    testOrder.AliquotOrder = aliquotOrder;
                                }
                                else
                                {
                                    aliquotOrder = testOrder.AliquotOrder;
                                }

                                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(aliquotOrder, dataTableReader);
                                sqlDataTableReaderPropertyWriter.WriteProperties();
                            }
                        }
                    }
                }
            }
        }
        public void Sync(DataTable dataTable, string reportNo)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string panelSetOrderCPTCodeId = dataTableReader["PanelSetOrderCPTCodeId"].ToString();
                string cptCodeReportNo        = dataTableReader["ReportNo"].ToString();

                PanelSetOrderCPTCode panelSetOrderCPTCode = null;

                if (this.Exists(panelSetOrderCPTCodeId) == true)
                {
                    panelSetOrderCPTCode = this.Get(panelSetOrderCPTCodeId);
                }
                else if (reportNo == cptCodeReportNo)
                {
                    panelSetOrderCPTCode = new PanelSetOrderCPTCode();
                    this.Add(panelSetOrderCPTCode);
                }

                if (panelSetOrderCPTCode != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(panelSetOrderCPTCode, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #13
0
        private void HandleTestOrderAliquotOrder(DataTable dataTable)
        {
            DataTableReader dataTableReader = new DataTableReader(dataTable);
            while (dataTableReader.Read())
            {
                string aliquotOrderId = dataTableReader["AliquotOrderId"].ToString();
                YellowstonePathology.Business.Test.AliquotOrder_Base aliquotOrder = null;
                foreach(Business.Test.PanelSetOrder panelSetOrder in this.m_AccessionOrder.PanelSetOrderCollection)
                {
                    foreach(Business.Test.PanelOrder panelOrder in panelSetOrder.PanelOrderCollection)
                    {
                        foreach(Business.Test.Model.TestOrder testOrder in panelOrder.TestOrderCollection)
                        {
                            if (testOrder.AliquotOrderId == aliquotOrderId)
                            {
                                if (testOrder.AliquotOrder == null)
                                {
                                    aliquotOrder = new Test.AliquotOrder();
                                    testOrder.AliquotOrder = aliquotOrder;
                                }
                                else
                                {
                                    aliquotOrder = testOrder.AliquotOrder;
                                }

                                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(aliquotOrder, dataTableReader);
                                sqlDataTableReaderPropertyWriter.WriteProperties();
                            }
                        }
                    }
                }

            }
        }
Пример #14
0
        private void HandleSlideOrderTestOrder(DataTable dataTable)
        {
            DataTableReader dataTableReader = new DataTableReader(dataTable);
            while (dataTableReader.Read())
            {
                string testOrderId = dataTableReader["TestOrderId"].ToString();
                YellowstonePathology.Business.Test.Model.TestOrder_Base testOrder = null;
                foreach (Business.Specimen.Model.SpecimenOrder specimenOrder in this.m_AccessionOrder.SpecimenOrderCollection)
                {
                    foreach (Business.Test.AliquotOrder aliquotOrder in specimenOrder.AliquotOrderCollection)
                    {
                        foreach (Business.Slide.Model.SlideOrder slideOrder in aliquotOrder.SlideOrderCollection)
                        {
                            if (slideOrder.TestOrderId == testOrderId)
                            {
                                if (slideOrder.TestOrder == null)
                                {
                                    testOrder = new Test.Model.TestOrder();
                                    slideOrder.TestOrder = testOrder;
                                }
                                else
                                {
                                    testOrder = slideOrder.TestOrder;
                                }

                                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(testOrder, dataTableReader);
                                sqlDataTableReaderPropertyWriter.WriteProperties();
                            }
                        }
                    }
                }
            }
        }
Пример #15
0
        public void Sync(DataTable dataTable, string taskOrderId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string taskOrderDetailId          = dataTableReader["TaskOrderDetailId"].ToString();
                string taskOrderDetailTaskOrderId = dataTableReader["TaskOrderId"].ToString();
                string taskId = dataTableReader["TaskId"].ToString();

                TaskOrderDetail taskOrderDetail = null;

                if (this.Exists(taskOrderDetailId) == true)
                {
                    taskOrderDetail = this.Get(taskOrderDetailId);
                }
                else if (taskOrderId == taskOrderDetailTaskOrderId)
                {
                    taskOrderDetail = TaskOrderDetailFactory.GetTaskOrderDetail(taskId);
                    this.Add(taskOrderDetail);
                }

                if (taskOrderDetail != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(taskOrderDetail, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
        public void Sync(DataTable dataTable, string reportNo)
        {
            this.RemoveDeleted(dataTable, reportNo);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string id             = dataTableReader["RetrospectiveReviewTestOrderDetailId"].ToString();
                string detailReportNo = dataTableReader["ReportNo"].ToString();
                RetrospectiveReviewTestOrderDetail rsrd = null;

                if (this.Exists(id) == true)
                {
                    rsrd = this.Get(id);
                }
                else
                {
                    if (detailReportNo == reportNo)
                    {
                        rsrd = new RetrospectiveReviewTestOrderDetail();
                        this.Add(rsrd);
                    }
                }

                if (rsrd != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(rsrd, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #17
0
        public void Sync(DataTable dataTable, string specimenOrderId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string aliquotOrderId         = dataTableReader["AliquotOrderId"].ToString();
                string aliquotSpecimenOrderId = dataTableReader["SpecimenOrderId"].ToString();

                Business.Test.AliquotOrder aliquotOrder = null;

                if (this.Exists(aliquotOrderId) == true)
                {
                    aliquotOrder = this.GetByAliquotOrderId(aliquotOrderId);
                }
                else if (aliquotSpecimenOrderId == specimenOrderId)
                {
                    aliquotOrder = new Business.Test.AliquotOrder();
                    this.Add(aliquotOrder);
                }

                if (aliquotOrder != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(aliquotOrder, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #18
0
        public void Sync(DataTable dataTable)
        {
            this.IsLoading = true;
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string specimenOrderId = dataTableReader["SpecimenOrderId"].ToString();

                Business.Specimen.Model.SpecimenOrder specimenOrder = null;

                if (this.Exists(specimenOrderId) == true)
                {
                    specimenOrder = this.GetSpecimenOrder(specimenOrderId);
                }
                else
                {
                    specimenOrder = new Business.Specimen.Model.SpecimenOrder();
                    this.Add(specimenOrder);
                }

                YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(specimenOrder, dataTableReader);
                sqlDataTableReaderPropertyWriter.WriteProperties();
            }

            this.IsLoading = false;
        }
Пример #19
0
        public void Sync(DataTable dataTable, string surgicalAuditId)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string surgicalSpecimenAuditId = dataTableReader["SurgicalSpecimenAuditId"].ToString();
                string specimenSurgicalAuditId = dataTableReader["SurgicalAuditId"].ToString();

                SurgicalSpecimenAudit surgicalSpecimenAudit = null;

                if (this.Exists(surgicalSpecimenAuditId) == true)
                {
                    surgicalSpecimenAudit = this.Get(surgicalSpecimenAuditId);
                }
                else if (surgicalAuditId == specimenSurgicalAuditId)
                {
                    surgicalSpecimenAudit = new SurgicalSpecimenAudit();
                    this.Add(surgicalSpecimenAudit);
                }

                if (surgicalSpecimenAudit != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(surgicalSpecimenAudit, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }
Пример #20
0
        public void Sync(DataTable dataTable)
        {
            this.RemoveDeleted(dataTable);
            DataTableReader dataTableReader = new DataTableReader(dataTable);

            while (dataTableReader.Read())
            {
                string amendmentId = dataTableReader["AmendmentId"].ToString();

                Amendment amendment = null;

                if (this.Exists(amendmentId) == true)
                {
                    amendment = this.GetAmendment(amendmentId);
                }
                else
                {
                    amendment = new Amendment();
                    this.Add(amendment);
                }

                if (amendment != null)
                {
                    YellowstonePathology.Business.Persistence.SqlDataTableReaderPropertyWriter sqlDataTableReaderPropertyWriter = new Persistence.SqlDataTableReaderPropertyWriter(amendment, dataTableReader);
                    sqlDataTableReaderPropertyWriter.WriteProperties();
                }
            }
        }