/LISAssayImporter/LISAssayImporter.cs

Large files files are truncated, but you can click here to view the full file

using System;

using System.Collections.Generic;

using System.Text;

using System.Data.Odbc;

using System.Xml;

using System.Xml.Serialization;

using System.IO;

using System.Net;

using System.Diagnostics;

using ADX4;

using ADX4.Tools.Validation;

using ADX4.Tools;



namespace LISAssayImporter

{

    public partial class AssayImporter

    {

        #region Enumerations

        private enum Mappings

        {

            Analytes,

            Analyte,

            MapsTo,

        };

        #endregion



        #region Internal Classes

        public class LabProperty

        {

            public String m_assayType;

            public String m_lowerDetection;

            public String m_upperDetection;

            public String m_analyticalWeight;

            public String m_analysisMethod;

            public String m_units;

        }

        #endregion



        #region Constants

        private const string c_basicHttpBinding = "BasicHttpBinding_ILabIntegrationServices";

        private const string c_wsHttpBinding = "WSHttpBinding_ILabIntegrationServices";



        private const string c_useHttpsSwitch = "/UseHttps";

        private const string c_importIntoStd = "/Standard";

        private const string c_saveAdxToFile = "/Save";

        private const string c_applyAliasesSwitch = "/ApplyAliases";

        private const string c_strictLabPropertiesSwitch = "/StrictLabProperties";

        private const string c_importLabStdsSwitch = "/ImportLabStds";

        private const string c_importDupsSwitch = "/ImportDups";

        private const string c_triggerProxySwitch = "/TriggerProxy";

        private const string c_queryDatesSwitch = "/QueryDates";

        private const string c_queryDespatchSwitch = "/QueryDespatch";

        private const string c_queryLabjobSwitch = "/QueryLabjob";

        private const string c_userNameSwitch = "/UserName";

        private const string c_passwordSwitch = "/Password";

        private const string c_ignoreOrphanSamples = "/IgnoreOrphanSamples";



        private const string c_defaultLabJobField = "SubmissionLabJob";

        private const string c_defaultResultField = "SubmissionError";



        private const string c_electronicAssayRetrieval = "Electronic Assay Retrieval";

        private const string c_electronicAssayTypes = "Assay Types";

        private const string c_electronicLabJobs = "Labjobs";

        private const string c_electronicUnits = "Units";

        private const string c_electronicAnalysisMethods = "Analysis Methods";

        private const string c_electronicDsc = "DSC";

        private const string c_electronicProcessingPath = "Processing Paths";

        private const string c_electronicDownloadError = "Download Error";

        private const string c_electronicDefaults = "Defaults";

        private const string c_electronicDefaultsUserName = "LaboratoryUserName";

        private const string c_electronicDefaultsPassword = "LaboratoryPassword";

        private const string c_electronicNewLabReferenceMaterialId = "NewLabReferenceMaterialId";

        private const string c_electronicNewDuplicateMaterialId = "NewDuplicateMaterialId";

        private const string c_electronicConvertLabStandardId = "ConvertLabStandardId";

        private const string c_electronicNewLabStandardId = "NewLabStandardId";

        

        private enum specialProcedures {ReceivedSampleWeight,AnalyticalWeight,AnalyticalOrder };

        private List<String> c_electronicSpecialProcedures = new List<String>() { "Received Sample Weight", "Analytical Weight", "Analytical Order" };

        //private const string c_electronicReceivedSampleWeight = "Received Sample Weight";

        //private const string c_electronicAnalyticalWeight = "Analytical Weight";

        //private const string c_electronicAnalyticalOrder = "Analytical Order";



        private string c_labBlankType = "LAB_BLANK";

        private string c_labStandardType = "LAB_STD";

        private string c_labStdDescription = "Created during assay download from laboratory";

        private char[] c_processingPathSeparator = new char[1] { ',' };

        #endregion



        #region Variables

        private int m_errorCount = 0;

        private string m_odbcDsn;

        private string m_odbcUserName;

        private string m_odbcPassword;

        private string m_adxFileName;

        private string m_retrievalContext;

        private string m_labJobNo;

        private string m_labUserName;

        private string m_labPassword;

        private string m_labServer;

        private Boolean m_ignoreOrphanSamples = false;

        private Boolean m_importDupsSwitch = false;

        private Boolean m_importIntoCorp = true;

        private OdbcConnection m_odbc;

        private List<String> m_errorLabMessages = new List<string>();

        private Dictionary<String, String> m_unitsMapping;

        private Dictionary<String, String> m_analysisMethodsMapping;

        private Dictionary<String,String> m_assayTypesMapping;

        private Dictionary<String, String> m_dscMapping;

        private Dictionary<String, String> m_processingPathMapping;

        private List<String> m_acQuireDsc;

        private List<String> m_acQuireUnits;

        private List<String> m_acQuireAssayTypes;

        private List<String> m_acQuireAnalysisMethods;

        private List<String> m_acQuireCheckStages;

        private String m_newLabReferenceMaterialId;

        private String m_newDuplicateMaterialId;

        private String m_convertLabStandardId;

        private String m_newLabStandardId;

        private Boolean m_importAllowed = true;

        private Boolean m_useHttps = false;

        private Boolean m_applyAliases = false;

        private Boolean m_importLabStdsSwitch = false;

        private String m_labStdsPrefix = "LABSTD";

        private Int32 m_labStdsCount = 1;

        private Boolean m_strictLabPropertiesSwitch = false;

        private Boolean m_queryDatesSwitch = false;

        private DateTime m_queryDatesStart;

        private DateTime m_queryDatesFinish;

        private Boolean m_queryDespatchSwitch = false;

        private String m_queryDespatchName;

        private Boolean m_queryLabjobSwitch = false;

        private String m_queryLabJobNo;



        #endregion



        #region Properties

        public string LabJobNo

        {

            get

            {

                return m_labJobNo;

            }

            set

            {

                m_labJobNo = value;

            }

        }



        public string ODBCdsn

        {

            get

            {

                return m_odbcDsn;

            }

            set

            {

                m_odbcDsn = value;

            }

        }

        public String LabUserName

        {

            get

            {

                return m_labUserName;

            }

            set

            {

                m_labUserName = value;

            }

        }



        public String LabPassword

        {

            get

            {

                return m_labPassword;

            }

            set

            {

                m_labPassword = value;

            }

        }



        public String LabServer

        {

            get

            {

                return m_labServer;

            }

            set

            {

                m_labServer = value;

            }

        }





        public Boolean ImportIntoCorpModel

        {

            get

            {

                return m_importIntoCorp;

            }

            set

            {

                m_importIntoCorp = value;

            }

        }



        public Boolean ApplyAliases

        {

            get

            {

                return m_applyAliases;

            }

            set

            {

                m_applyAliases = value;

            }

        }



        public Boolean UseHttps

        {

            get

            {

                return m_useHttps;

            }

            set

            {

                m_useHttps = value;

            }

        }



        public String RetrievalContext

        {

            get

            {

                return m_retrievalContext;

            }

            set

            {

                m_retrievalContext = value;

            }

        }

                    

        public Boolean StrictLabProperties

        {

            get

            {

                return m_strictLabPropertiesSwitch;

            }

            set

            {

                m_strictLabPropertiesSwitch = value;

            }

        }



        public Boolean ImportLabStdsSwitch

        {

            get

            {

                return m_importLabStdsSwitch;

            }

            set

            {

                m_importLabStdsSwitch = value;

            }

        }



        public String NewDuplicateMaterialId

        {

            get

            {

                return m_newDuplicateMaterialId;

            }

            set

            {

                m_newDuplicateMaterialId = value;

            }

        }



        public String NewLabReferenceMaterialId

        {

            get

            {

                return m_newLabReferenceMaterialId;

            }

            set

            {

                m_newLabReferenceMaterialId = value;

            }

        }



        public String NewLabStandardId

        {

            get

            {

                return m_newLabStandardId;

            }

            set

            {

                m_newLabStandardId = value;

            }

        }



        public String ConvertLabStandardId

        {

            get

            {

                return m_convertLabStandardId;

            }

            set

            {

                m_convertLabStandardId = value;

            }

        }



        public Boolean QueryRequired

        {

            get

            {

                return m_queryDatesSwitch || m_queryDespatchSwitch || m_queryLabjobSwitch;

            }

        }

        #endregion



        public Boolean Parse(string[] args)

        {

            // Parse the switches

            int curArg = 0;

            m_importIntoCorp = true;

            m_adxFileName = null;

            m_useHttps = false;

            m_applyAliases = false;

            m_importLabStdsSwitch = false;

            m_strictLabPropertiesSwitch = false;

            for (int i = 0; i < args.Length && curArg < args.Length; i++)

            {

                // ImportIntoStd switch

                if (String.Compare(c_importIntoStd, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_importIntoCorp = false;

                }



                // ODBC user name switch

                else if (String.Compare(c_userNameSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_odbcUserName = args[curArg++];

                }



                // ODBC password switch

                else if (String.Compare(c_passwordSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_odbcPassword = args[curArg++];

                }



                // StrictLabProperties switch

                else if (String.Compare(c_strictLabPropertiesSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_strictLabPropertiesSwitch = true;

                }



                // StrictLabProperties switch

                else if (String.Compare(c_ignoreOrphanSamples, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_ignoreOrphanSamples = true;

                }



                // ImportLabStdsSwitch switch

                else if (String.Compare(c_importLabStdsSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_labStdsPrefix = args[curArg++];

                    m_importLabStdsSwitch = true;

                }





                // ImportDups switch

                else if (String.Compare(c_importDupsSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_importDupsSwitch = true;

                }

                    

                // Apply aliases

                else if (String.Compare(c_applyAliasesSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_applyAliases = true;

                }



                // Use https

                else if (String.Compare(c_useHttpsSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_useHttps = true;

                }



                // Query labjob

                else if (String.Compare(c_queryLabjobSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_queryLabJobNo = args[curArg++];

                    m_queryLabjobSwitch = true;

                }



                // Query despatch

                else if (String.Compare(c_queryDespatchSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_queryDespatchName = args[curArg++];

                    m_queryDespatchSwitch = true;

                }



                // Query dates

                else if (String.Compare(c_queryDatesSwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    try

                    {

                        m_queryDatesStart = DateTime.Parse(args[curArg++]);

                    }

                    catch (System.Exception exc)

                    {

                        return false;

                    }



                    if (curArg >= args.Length)

                        return false;



                    try

                    {

                        m_queryDatesFinish = DateTime.Parse(args[curArg++]);

                    }

                    catch (System.Exception exc)

                    {

                        return false;

                    }

                    m_queryDatesSwitch = true;

                }



                // Save ADX to file switch

                else if (String.Compare(c_saveAdxToFile, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    m_adxFileName = args[curArg++];

                }



                // Add the trigger proxy field

                else if (String.Compare(c_triggerProxySwitch, args[curArg], true) == 0)

                {

                    curArg++;

                    if (curArg >= args.Length)

                        return false;



                    try

                    {

                        HttpWebRequest triggerProxy = (HttpWebRequest)HttpWebRequest.Create("http://www.google.com");

                        triggerProxy.UseDefaultCredentials = true;

                        triggerProxy.GetResponse();

                    }

                    catch (System.Exception exc)

                    {

                        Console.WriteLine(exc.Message);

                    }

                }

            }



            // Get ODBC name

            if (curArg >= args.Length)

                return false;

            this.ODBCdsn = args[curArg++];



            // Get lab job context

            if (curArg >= args.Length)

                return false;

            this.RetrievalContext = args[curArg++];



            // Get lab job name

            if (curArg >= args.Length)

                return false;

            this.LabJobNo = args[curArg++];



            // Get laboratory server

            if (curArg >= args.Length)

                return false;

            this.LabServer = args[curArg++];



            // Get laboratory user name

            if (curArg < args.Length)

                this.LabUserName = args[curArg++];



            // Get laboratory password

            if (curArg < args.Length)

                this.LabPassword = args[curArg++];



            return true;

        }



        public void Connect()

        {

            // Open the connection

            try

            {

                m_odbc = new OdbcConnection();

                m_odbc.ConnectionString = String.Concat("DSN=",this.ODBCdsn,";");

                if (!String.IsNullOrEmpty(this.m_odbcUserName) && !String.IsNullOrEmpty(this.m_odbcPassword))

                {

                    m_odbc.ConnectionString = String.Concat(m_odbc.ConnectionString, "Uid=", this.m_odbcUserName, ";");

                    m_odbc.ConnectionString = String.Concat(m_odbc.ConnectionString, "Pwd=", this.m_odbcPassword, ";");

                }

                m_odbc.Open();





                if (String.IsNullOrEmpty(this.LabUserName))

                    this.LabUserName = this.GetLaboratoryUserName();



                if (String.IsNullOrEmpty(this.LabPassword))

                    this.LabPassword = this.GetLaboratoryPassword();

            }

            // Trap and throw exceptions higher up

            catch(SystemException exc)

            {

                m_odbc = null;

                throw exc;

            }

        }



        public void Close()

        {

            if (m_odbc == null)

                return;



            // Close the connection

            try

            {

                m_odbc.Close();

            }

            // Trap and throw exceptions higher up

            catch (SystemException exc)

            {

                throw exc;

            }

        }



        public ADX GetLabJob()

        {

            Laboratory.LabIntegrationServicesClient laboratory;

            if (m_useHttps)

                laboratory = new Laboratory.LabIntegrationServicesClient("WSHttpBinding_ILabIntegrationServices", this.LabServer);

            else

                laboratory = new Laboratory.LabIntegrationServicesClient("BasicHttpBinding_ILabIntegrationServices", this.LabServer);



            laboratory.ClientCredentials.UserName.UserName = this.LabUserName;

            laboratory.ClientCredentials.UserName.Password = this.LabPassword;



            Laboratory.LabIntegrationContext context = new LISAssayImporter.Laboratory.LabIntegrationContext();

            context.Name = this.RetrievalContext;

            ADX[] results = laboratory.GetLabJobResults(context,this.m_labJobNo);

            if (results == null || results.Length != 1)

                return null;



            DocumentValidation validator = new DocumentValidation();

            validator.Check(results[0], ValidationLevel.LaboratoryExport, this.CleanSampleId);



            if (validator.Count > 0)

            {

                foreach (ValidationResult result in validator)

                    if (result.level == ErrorLevel.Error)

                        this.LogLaboratoryError(String.Format(Language.errValidationError, result.message));

            }



            return results[0];

        }



        public void ReportLabErrors(ADX results)

        {

            Laboratory.LabIntegrationServicesClient laboratory;

            if (m_useHttps)

                laboratory = new Laboratory.LabIntegrationServicesClient("WSHttpBinding_ILabIntegrationServices", this.LabServer);

            else

                laboratory = new Laboratory.LabIntegrationServicesClient("BasicHttpBinding_ILabIntegrationServices", this.LabServer);



            laboratory.ClientCredentials.UserName.UserName = this.LabUserName;

            laboratory.ClientCredentials.UserName.Password = this.LabPassword;



            Laboratory.ActionResult error = new LISAssayImporter.Laboratory.ActionResult();

            error.ErrorCode = -1;

            error.Status = LISAssayImporter.Laboratory.ActionResult.ResultStatus.Rejected;

            error.Message = String.Format("Labjob: {0}|",this.LabJobNo);

            foreach(String message in m_errorLabMessages)

                error.Message = String.Concat(error.Message,message,"|");



            Laboratory.LabIntegrationContext context = new LISAssayImporter.Laboratory.LabIntegrationContext();

            context.Name = this.RetrievalContext;

            

            laboratory.ReportInformationError(context, error, results);

        }



        public void Import(ADX document)

        {

            m_importAllowed = true;



            ReadSettings();



            // Import the ADX document into acQuire

            SendToCorpModel(document);

        }



        private void ReadSettings()

        {

            try

            {

                OdbcCommand odbcCmd = new OdbcCommand(String.Format("delete from METAIMPORTALIASES where CATEGORY = '{0}' and SUBCATEGORY = '{1}'", c_electronicAssayRetrieval, c_electronicDownloadError), this.m_odbc);

                odbcCmd.ExecuteNonQuery();

            }

            catch (System.Exception exc)

            {

            }



            try

            {

                OdbcCommand odbcCmd = new OdbcCommand(String.Format("select MAX(CAST(SUBSTRING(CHECKID,LEN('{0}')+1,100) as int))+1 from CHECKSAMPLE where CHECKID like '{1}%'", m_labStdsPrefix,m_labStdsPrefix), this.m_odbc);

                Object result = odbcCmd.ExecuteScalar();

                m_labStdsCount = (result == null || result == DBNull.Value ? 1 : (int)result);

            }

            catch (System.Exception exc)

            {

            }



            m_analysisMethodsMapping = GetAnalysisMethods();

            m_assayTypesMapping = GetAssayTypeMapping();

            m_unitsMapping = GetUnitsMapping();

            m_dscMapping = GetDscMapping();

            m_processingPathMapping = GetProcessingPathMapping();



            m_acQuireAnalysisMethods = GetacQuireAnalysisMethods();

            m_acQuireDsc = GetacQuireDSC();

            m_acQuireAssayTypes = GetacQuireAssayTypes();

            m_acQuireUnits = GetacQuireUnits();

            m_acQuireCheckStages = GetacQuireCheckStages();



            m_newDuplicateMaterialId = GetSetting(c_electronicNewDuplicateMaterialId);

            m_newLabReferenceMaterialId = GetSetting(c_electronicNewLabReferenceMaterialId);

            m_convertLabStandardId = GetSetting(c_electronicConvertLabStandardId);

            m_newLabStandardId = GetSetting(c_electronicNewLabStandardId);

        }



        private void SendToCorpModel(ADX document)

        {

            CheckLabJob(document);



            List<LabProperty> labProperties = CheckLabCorpProperties(document);



            CheckAssays(document);



            if (this.m_importAllowed)

            {

                AddLabJob(document);



                AddLabCorpProperties(document, labProperties);



                AddAssays(document, labProperties);

            }

            else if (m_errorLabMessages.Count > 0)

                ReportLabErrors(document);

        }



        /// <summary>

        /// Checks the lab job information for errors.

        /// </summary>

        /// <param name="document">The ADX document.</param>

        private void CheckLabJob(ADX document)

        {

            OdbcCommand odbcCmd;



            // Is there an ADX lab job ?

            if (document.Header == null || document.Header.AnalyticalReport == null || document.Header.AnalyticalReport.LabJob == null)

            {

                LogLaboratoryError(Language.errNoLabjobSpecified);

            }

            else

            {

                // Is the ADX LAB JOB in the acQuire database ?

                odbcCmd = new OdbcCommand(String.Concat("select 1 from DESPATCHRETURN where LABJOBNO = '", document.Header.AnalyticalReport.LabJob, "'"), this.m_odbc);

                if (odbcCmd.ExecuteScalar() != null)

                    LogLocalError(String.Format(Language.errLabjobIsAlreadyLoaded, document.Header.AnalyticalReport.LabJob));

            }



            // Is there a DespatchNo in the ADX document ?

            if (document.Header == null || document.Header.Despatch == null || String.IsNullOrEmpty(document.Header.Despatch.DespatchNo) || true)

            {

                String despatchNo = SearchForDespatch(document);

                if (String.IsNullOrEmpty(despatchNo))

                {

                    LogLocalError(Language.errNoDespatchSpecified);

                    return;

                }

                else

                {

                    if (document.Header == null)

                        document.Header = new Header();

                    if (document.Header.Despatch == null)

                        document.Header.Despatch = new DespatchDetails();

                    document.Header.Despatch.DespatchNo = despatchNo;

                }

            }



            if (String.IsNullOrEmpty(document.Header.Despatch.DespatchNo))

            {

                LogLocalError(Language.errNoDespatchSpecified);

                return;

            }



            // Is the ADX DespatchNo in the acQuire database ?

            odbcCmd = new OdbcCommand(String.Concat("select 1 from DESPATCHSEND where DESPATCHNO = '", document.Header.Despatch.DespatchNo, "'"), this.m_odbc);

            if (odbcCmd.ExecuteScalar() == null)

            {

                LogLaboratoryError(String.Format(Language.errDespatchNotListedInDatabase, document.Header.Despatch.DespatchNo));

                return;

            }

        }



        /// <summary>

        /// Searches for the despatch matching this labjob using the SubmissionLabJob field.

        /// <remarks>This search only works if the despatch was submitted electronically.</remarks>

        /// </summary>

        /// <param name="document">The ADX document.</param>

        /// <returns>The matching despatch</returns>

        private String SearchForDespatch(ADX document)

        {

            OdbcCommand odbcCmd = new OdbcCommand(String.Concat("select DESPATCHNO from DESPATCHDETAILS where NAME = '", c_defaultLabJobField, "' and VALUE = '", document.Header.AnalyticalReport.LabJob, "'"), this.m_odbc);

            Object despatchNo = odbcCmd.ExecuteScalar();

            if (despatchNo != null)

                return despatchNo.ToString();



            return null;

        }



        private List<LabProperty> CheckLabCorpProperties(ADX document)

        {

            // Get the analysis suite definition for this despatch 

            OdbcCommand odbcCmd = new OdbcCommand(String.Concat("select ANALYSISSUITE from DESPATCHSEND where DESPATCHNO = '", document.Header.Despatch.DespatchNo, "'"), this.m_odbc);

            Object result = odbcCmd.ExecuteScalar();

            String analysisSuite = (result == null ? null : result.ToString());



            List<String> analysisSuiteDef = new List<string>();

            if (!String.IsNullOrEmpty(analysisSuite))

                analysisSuiteDef = GetacQuireAnalysisSuite(analysisSuite);



            ProcessingTrees processingTrees = new ProcessingTrees(document, this.ValidationEventCallback,this.CleanSampleId);

            processingTrees.Build(document.Results.ProcessingGroup);



            List<LabProperty> labProperties = new List<LabProperty>();

            foreach (ProcessingTree processingTree in processingTrees)

            {

                foreach (AssayRecord assayRecord in processingTree)

                {

                    Procedure sampleWeightProcedure = assayRecord.ProcessingHistory.FindProcedure(c_electronicSpecialProcedures[(int)specialProcedures.ReceivedSampleWeight]);

                    if (sampleWeightProcedure is WeighingProcedure)

                    {

                        // Is this property in the analysis suite definition ?

                        String assayType = c_electronicSpecialProcedures[(int)specialProcedures.ReceivedSampleWeight];

                        if (this.ApplyAliases)

                            if (m_assayTypesMapping.ContainsKey(assayType))

                                assayType = m_assayTypesMapping[assayType];



                        if (analysisSuiteDef.Count == 0 || analysisSuiteDef.Contains(assayType))

                        {

                            Measurement sampleWeight = new Measurement();

                            sampleWeight.ProcedureRef = c_electronicSpecialProcedures[(int)specialProcedures.ReceivedSampleWeight];

                            sampleWeight.Status = MeasurementStatus.Detected;

                            sampleWeight.StatusSpecified = true;

                            sampleWeight.Property = c_electronicSpecialProcedures[(int)specialProcedures.ReceivedSampleWeight];

                            sampleWeight.Value = (sampleWeightProcedure as WeighingProcedure).Mass;

                            ExtractLabCorpProperty(labProperties, new AssayMeasurement(sampleWeight,sampleWeightProcedure));

                        }

                    }



                    foreach (AssayMeasurement measurement in assayRecord)

                    {

                        if (measurement.Procedure == null || String.IsNullOrEmpty(measurement.Procedure.Id))

                            continue;



                        ExtractLabCorpProperty(labProperties, measurement);

                    }

                }

            }



            // Map the lab properties to acquire codes

            foreach (LabProperty labProperty in labProperties)

            {

                // Is this property in the analysis suite definition ?

                if (analysisSuiteDef.Count > 0)

                    if (!analysisSuiteDef.Contains(labProperty.m_assayType) && !c_electronicSpecialProcedures.Contains(labProperty.m_assayType))

                        LogLaboratoryError(String.Format(Language.errAssayTypeNotInDespatchAnalysisSuite, labProperty.m_assayType, document.Header.Despatch.DespatchNo, analysisSuite));



                // Check the units

                if (String.IsNullOrEmpty(labProperty.m_units))

                    LogLaboratoryError(String.Format(Language.errNoUnitsSpecified, labProperty.m_assayType));



                else if (this.ApplyAliases)

                {

                    if (m_unitsMapping.ContainsKey(labProperty.m_units))

                        labProperty.m_units = m_unitsMapping[labProperty.m_units];



                    if (!m_acQuireUnits.Contains(labProperty.m_units))

                        LogLaboratoryError(String.Format(Language.errUnitsNotRecognised, labProperty.m_units,labProperty.m_assayType));

                }

                else if (!m_acQuireUnits.Contains(labProperty.m_units))

                    LogLaboratoryError(String.Format(Language.errUnitsNotRecognised, labProperty.m_units, labProperty.m_assayType));



                // Check the analysis method

                if (String.IsNullOrEmpty(labProperty.m_analysisMethod) && this.StrictLabProperties)

                    LogLaboratoryError(String.Format(Language.errNoAnalysisMethodSpecified, labProperty.m_assayType));



                else  if (!String.IsNullOrEmpty(labProperty.m_analysisMethod))

                {

                    if (this.ApplyAliases)

                    {

                        if (m_analysisMethodsMapping.ContainsKey(labProperty.m_analysisMethod))

                            labProperty.m_analysisMethod = m_analysisMethodsMapping[labProperty.m_analysisMethod];



                        if (!m_acQuireAnalysisMethods.Contains(labProperty.m_analysisMethod))

                        {

                            if (this.StrictLabProperties)

                                LogLaboratoryError(String.Format(Language.errAnalysisMethodNotRecognised, labProperty.m_analysisMethod, labProperty.m_assayType));

                            else

                                labProperty.m_analysisMethod = "";

                        }

                    }

                    else if (!m_acQuireAnalysisMethods.Contains(labProperty.m_analysisMethod))

                    {

                        if (this.StrictLabProperties)

                            LogLaboratoryError(String.Format(Language.errAnalysisMethodNotRecognised, labProperty.m_analysisMethod, labProperty.m_assayType));

                        else

                            labProperty.m_analysisMethod = "";

                    }

                }



                // Check the lower detection limit

                if (String.IsNullOrEmpty(labProperty.m_lowerDetection) && this.StrictLabProperties)

                {

                    LogLaboratoryError(String.Format(Language.errNoLowerDetectionLimitSpecified, labProperty.m_assayType));

                }

                else if (!String.IsNullOrEmpty(labProperty.m_lowerDetection))

                {

                    try

                    {

                        Double.Parse(labProperty.m_lowerDetection);

                    }

                    catch (System.Exception exc)

                    {

                        LogLaboratoryError(String.Format(Language.errLowerDetectionNotRecognised, labProperty.m_lowerDetection, labProperty.m_assayType));

                    }

                }



                // Check the upper detection limit

                if (String.IsNullOrEmpty(labProperty.m_upperDetection) && this.StrictLabProperties)

                {

                    LogLaboratoryError(String.Format(Language.errNoUpperDetectionLimitSpecified, labProperty.m_assayType));

                }

                else if (!String.IsNullOrEmpty(labProperty.m_upperDetection))

                {

                    try

                    {

                        Double.Parse(labProperty.m_upperDetection);

                    }

                    catch (System.Exception exc)

                    {

                        LogLaboratoryError(String.Format(Language.errUpperDetectionNotRecognised, labProperty.m_upperDetection, labProperty.m_assayType));

                    }

                }



                // Check if the lab properties are already loaded

                odbcCmd = new OdbcCommand(String.Concat("select 1 from CORPLABPROPERTIES where LABJOBNO = '", document.Header.AnalyticalReport.LabJob, "' and NAME = '", labProperty.m_assayType, "'"), this.m_odbc);

                if (odbcCmd.ExecuteScalar() != null)

                    LogLocalError(String.Format(Language.errLabPropertyAlreadyLoaded, labProperty.m_assayType,document.Header.AnalyticalReport.LabJob));

            }



            return labProperties;

        }



        private void ExtractLabCorpProperty(List<LabProperty> labProperties, AssayMeasurement measurement)

        {

            String assayType = measurement.Procedure.Id;

            if (String.IsNullOrEmpty(assayType))

                LogLaboratoryError(String.Format(Language.errNoProcedureRefSpecified, assayType));



            else if (this.ApplyAliases)

            {

                if (m_assayTypesMapping.ContainsKey(assayType))

                    assayType = m_assayTypesMapping[assayType];



                if (!m_acQuireAssayTypes.Contains(assayType) && !c_electronicSpecialProcedures.Contains(assayType))

                    LogLaboratoryError(String.Format(Language.errProcedureRefNotRecognised, assayType));

            }

            else if (!m_acQuireAssayTypes.Contains(assayType) && !c_electronicSpecialProcedures.Contains(assayType))

                LogLaboratoryError(String.Format(Language.errProcedureRefNotRecognised, assayType));



            Boolean found = false;

            foreach (LabProperty labProperty in labProperties)

            {

                if (String.Equals(labProperty.m_assayType, assayType))

                {

                    found = true;

                    break;

                }

            }

            if (!found)

            {

                LabProperty labProperty = new LabProperty();

                labProperty.m_assayType = assayType;



                if (measurement.Procedure is AnalysisProcedure)

                {

                    AnalysisProcedure analysisProcedure = measurement.Procedure as AnalysisProcedure;

                    labProperty.m_analysisMethod = analysisProcedure.Code;

                    labProperty.m_units = analysisProcedure.UOM;



                    if (analysisProcedure.BelowDetectionLimit != null && analysisProcedure.BelowDetectionLimit.Value != null)

                        labProperty.m_lowerDetection = analysisProcedure.BelowDetectionLimit.Value;



                    if (analysisProcedure.OverRangeLimit != null && analysisProcedure.OverRangeLimit.Value != null)

                        labProperty.m_upperDetection = analysisProcedure.OverRangeLimit.Value;

                }

                if (measurement.Procedure is WeighingProcedure)

                {

                    WeighingProcedure weighProcedure = measurement.Procedure as WeighingProcedure;

                    if (weighProcedure.Mass != null)

                        labProperty.m_units = weighProcedure.Mass.UOM;

                }



                labProperties.Add(labProperty);

            }

        }



        private void CheckAssays(ADX document)

        {

            if (document.Samples == null || document.Samples.Sample == null)

                LogLaboratoryError(String.Format(Language.errNoSamplesListIsSpecified));



            ProcessingTrees processingTrees = new ProcessingTrees(document, this.ValidationEventCallback, this.CleanSampleId);

            processingTrees.Build(document.Results.ProcessingGroup);



            foreach (ProcessingTree processingTree in processingTrees)

            {

                Boolean isLabStandard = false;

                if (document.Samples != null && document.Samples.Sample != null)

                {

                    foreach (SampleReference sampleRef in processingTree.SampleRefs)

                    {

                        Sample selectedSample = null;

                        foreach (Sample sample in document.Samples.Sample)

                            if (sample != null)

                                if (String.Equals(this.CleanSampleId(sample.Id), sampleRef.IdRef))

                                    selectedSample = sample;



                        if (selectedSample == null)

                            LogLaboratoryError(String.Format(Language.errBrokenSampleReference, sampleRef.IdRef));

                        else

                        {

                            OdbcCommand odbcCmd = new OdbcCommand(String.Concat("select 1 from SAMPLEDESPATCH where DESPATCHNO = '", document.Header.Despatch.DespatchNo, "' and SAMPLEID = '", CleanSampleId(sampleRef.IdRef), "'"), this.m_odbc);

                            if (odbcCmd.ExecuteScalar() == null)

                            {

                                odbcCmd = new OdbcCommand(String.Concat("select 1 from CHECKDESPATCH where DESPATCHNO = '", document.Header.Despatch.DespatchNo, "' and CHECKID = '", CleanSampleId(sampleRef.IdRef), "'"), this.m_odbc);

                                if (odbcCmd.ExecuteScalar() == null)

                                {

                                    if (!(selectedSample is ReferenceMaterial))

                                    {

                                        if (!m_ignoreOrphanSamples || processingTree.Count > 0)

                                            LogLaboratoryError(String.Format(Language.errSampleNotMemberOfDespatch, sampleRef.IdRef, document.Header.Despatch.DespatchNo));

                                    }

                                    else

                                        isLabStandard = true;

                                }

                            }

                        }

                    }

                }



                

                foreach (AssayRecord assayRecord in processingTree)

                {

                    if (assayRecord == null)

                        continue;



                    String checkStage = assayRecord.ProcessingPath.ToString();

                    if (this.ApplyAliases)

                        checkStage = MapProcessingPath(assayRecord);



                    if (!String.IsNullOrEmpty(checkStage))

                        if (!m_acQuireCheckStages.Contains(checkStage))

                            if (!isLabStandard)

                                LogLaboratoryError(String.Format(Language.errUnknownProcessingPath, (String.IsNullOrEmpty(assayRecord.InternalAnalysisId) ? "" : assayRecord.InternalAnalysisId), assayRecord.ProcessingPath.ToString()));



                    foreach (AssayMeasurement measurement in assayRecord)

                    {

                        if (measurement == null || measurement.Procedure == null)

                            continue;



                        String assayType = measurement.Procedure.Id;

                        if (String.IsNullOrEmpty(assayType))

                            LogLaboratoryError(String.Format(Language.errNoProcedureRefSpecified, assayType));

                        else

                        {

                            if (this.ApplyAliases)

                            {

                                if (m_assayTypesMapping.ContainsKey(measurement.Procedure.Id))

                                {

                                    assayType = m_assayTypesMapping[measurement.Procedure.Id];

                                    if (!m_acQuireAssayTypes.Contains(assayType))

                                        LogLocalError(String.Format(Language.errProcedureRefNotRecognised, measurement.Procedure.Id));

                                }

                            }

                            else if (!m_acQuireAssayTypes.Contains(assayType))

                                LogLaboratoryError(String.Format(Language.errProcedureRefNotRecognised, measurement.Procedure.Id));

                        }



                        String status = "";

                        if (measurement.Measurement.StatusSpecified)

                            status = measurement.Measurement.Status.ToString();

                        if (this.ApplyAliases)

                            if (m_dscMapping.ContainsKey(status))

                                status = m_dscMapping[status];



                        if (!m_acQuireDsc.Contains(status) && !String.IsNullOrEmpty(status))

                            LogLocalError(String.Format(Language.errDSCNotRecognised, status));



                        if (!String.IsNullOrEmpty(document.Header.AnalyticalReport.LabJob) && processingTree.SampleRefs.Count > 0 && !String.IsNullOrEmpty(processingTree.SampleRefs[0].IdRef))

                        {

                            OdbcCommand odbcCmd = new OdbcCommand(String.Concat("select 1 from CORPSAMPLEASSAY where LABJOBNO = '", document.Header.AnalyticalReport.LabJob, "' and SAMPLEID = '", CleanSampleId(processingTree.SampleRefs[0].IdRef), "' and NAME = '",assayType,"'"), this.m_odbc);

                            if (odbcCmd.ExecuteScalar() != null)

                                LogLocalError(String.Format(Language.errSampleAssayAlreadyLoaded, processingTree.SampleRefs[0].IdRef, assayType));



                            odbcCmd = new OdbcCommand(String.Concat("select 1 from CORPCHECKASSAY where LABJOBNO = '", document.Header.AnalyticalReport.LabJob, "' and CHECKID = '", CleanSampleId(processingTree.SampleRefs[0].IdRef), "' and NAME = '", assayType, "'"), this.m_odbc);

                            if (odbcCmd.ExecuteScalar() != null)

                                LogLocalError(String.Format(Language.errCheckAssayAlreadyLoaded, processingTree.SampleRefs[0].IdRef, assayType));

                        }

                    }

                }

            }

        }



        private void AddLabJob(ADX document)

        {

            OdbcCommand odbcCmd;



            // Add the lab job to acQuire

            odbcCmd = new OdbcCommand(String.Concat(new String[] { "insert into DESPATCHRETURN (LABJOBNO,RETURNDATE,DESPATCHNO) values(?,?,?)", }), this.m_odbc);

            odbcCmd.Parameters.Add(new OdbcParameter("@LABJOBNO",document.Header.AnalyticalReport.LabJob));

            odbcCmd.Parameters.Add(new OdbcParameter("@RETURNDATE", ConvertToacQuireDate(DateTime.Now)));

            odbcCmd.Parameters.Add(new OdbcParameter("@DESPATCHNO", document.Header.Despatch.DespatchNo));

            if (odbcCmd.ExecuteNonQuery() != 1)

            {

                LogLocalError(String.Format(Language.errLabJobDetailsCannotBeLoaded));

                return;

            }

        }



        private string ConvertToacQuireDate(DateTime dateTime)

        {

            string[] acQuireMonth = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

            return String.Format("{0}-{1}-{2}", dateTime.Day, acQuireMonth[dateTime.Month-1], dateTime.Year);

        }



        private void AddLabCorpProperties(ADX document,List<LabProperty> labProperties)

        {

            OdbcCommand odbcCmd;



            // Add the lab job property to acQuire

            foreach (LabProperty labProperty in labProperties)

            {

                odbcCmd = new OdbcCommand(String.Concat(new String[] { "insert into CORPLABPROPERTIES (LABJOBNO,DESPATCHNO,NAME,UOM,LABANALYSISMETHOD,LOWERDETECTION,UPPERDETECTION) values(?,?,?,?,?,?,?)", }), this.m_odbc);

                odbcCmd.Parameters.Add(new OdbcParameter("@LABJOBNO", document.Header.AnalyticalReport.LabJob));

                odbcCmd.Parameters.Add(new OdbcParameter("@DESPATCHNO", document.Header.Despatch.DespatchNo));

                odbcCmd.Parameters.Add(new OdbcParameter("@NAME", labProperty.m_assayType));

                odbcCmd.Parameters.Add(new OdbcParameter("@UOM", labProperty.m_units));



                if (String.IsNullOrEmpty(labProperty.m_analysisMethod))

                    odbcCmd.Parameters.Add(new OdbcParameter("@LABANALYSISMETHOD", DBNull.Value));

                else

                    odbcCmd.Parameters.Add(new OdbcParameter("@LABANALYSISMETHOD", labProperty.m_analysisMethod));



                if (String.IsNullOrEmpty(labProperty.m_lowerDetection))

                    odbcCmd.Parameters.Add(new OdbcParameter("@LOWERDETECTION", DBNull.Value));

                else

                    odbcCmd.Parameters.Add(new OdbcParameter("@LOWERDETECTION", labProperty.m_lowerDetection));



                if (String.IsNullOrEmpty(labProperty.m_upperDetection))

                    odbcCmd.Parameters.Add(new OdbcParameter("@UPPERDETECTION", DBNull.Value));

                else

                    odbcCmd.Parameters.Add(new OdbcParameter("@UPPERDETECTION", labProperty.m_upperDetection));



                if (odbcCmd.ExecuteNonQuery() != 1)

                    LogLocalError(String.Format(Language.errLabPropertyDetailsCannotBeLoaded, labProperty.m_assayType));

            }

        }



        private void AddAssays(ADX document, List<LabProperty> labProperties)

        {

            ProcessingTrees processingTrees = new ProcessingTrees(document,null,this.CleanSampleId);

            processingTrees.Build(document.Results.ProcessingGroup);



            foreach (ProcessingTree processingTree in processingTrees)

            {

                String sampleId = CleanSampleId(processingTree.SampleRefs[0].IdRef);



                Boolean isCheckSample = true;

                Boolean sampleExists = true;

                String checkDuplicateNo = null;

                Boolean isLabStandard = false;



                OdbcCommand odbcCmd = new OdbcCommand(String.Concat("select 1 from SAMPLEDESPATCH where DESPATCHNO = '", document.Header.Despatch.DespatchNo, "' and SAMPLEID = '", sampleId, "'"), this.m_odbc);

                if (odbcCmd.ExecuteScalar() != null)

                    isCheckSample = false;

                else

                {

                    odbcCmd = new OdbcCommand(String.Concat("select DUPLICATENO from CHECKDESPATCH where DESPATCHNO = '", document.Header.Despatch.DespatchNo…

Large files files are truncated, but you can click here to view the full file