MES_Client/TGMES/ONH/Core.ONH.Collection.comm/ONHDataHelper.cs

using System;
using System.IO;
using System.Linq;
using System.Xml.Linq;

namespace Core.ONH.Collection.comm
{
    public class ONHDataHelper
    {
        private static volatile ONHDataHelper _instance;

        private static readonly object LockHelper = new object();
        private readonly string _path;

        private int hDecimals;

        private bool hFlag;

        private int nDecimals;

        private bool nFlag;

        private int oDecimals;


        private bool oFlag;


        public Action<object, string> ReceiveData = null;

        /// <summary>
        ///     构造
        /// </summary>
        private ONHDataHelper()
        {
            _path = Environment.CurrentDirectory + "\\Decimals.xml";
            oFlag = XmlHelper.GetXmlData(_path, "OFlag", true);
            nFlag = XmlHelper.GetXmlData(_path, "NFlag", true);
            hFlag = XmlHelper.GetXmlData(_path, "HFlag", true);

            oDecimals = XmlHelper.GetXmlData(_path, "ODecimals", 4);
            nDecimals = XmlHelper.GetXmlData(_path, "NDecimals", 4);
            hDecimals = XmlHelper.GetXmlData(_path, "HDecimals", 5);
        }

        public bool OFlag
        {
            get { return oFlag; }
            set
            {
                if (oFlag != value)
                    XmlHelper.SetXmlData(_path, "OFlag", value ? "1" : "0");
                oFlag = value;
            }
        }

        public int ODecimals
        {
            get { return oDecimals; }
            set
            {
                if (oDecimals != value)
                    XmlHelper.SetXmlData(_path, "ODecimals", value + "");
                oDecimals = value;
            }
        }

        public bool NFlag
        {
            get { return nFlag; }
            set
            {
                if (nFlag != value)
                    XmlHelper.SetXmlData(_path, "NFlag", value ? "1" : "0");
                nFlag = value;
            }
        }

        public int NDecimals
        {
            get { return nDecimals; }
            set
            {
                if (nDecimals != value)
                    XmlHelper.SetXmlData(_path, "NDecimals", value + "");
                nDecimals = value;
            }
        }

        public bool HFlag
        {
            get { return hFlag; }
            set
            {
                if (hFlag != value)
                    XmlHelper.SetXmlData(_path, "HFlag", value ? "1" : "0");
                hFlag = value;
            }
        }

        public int HDecimals
        {
            get { return hDecimals; }
            set
            {
                if (hDecimals != value)
                    XmlHelper.SetXmlData(_path, "HDecimals", value + "");
                hDecimals = value;
            }
        }


        /// <summary>
        ///     单列模式
        /// </summary>
        /// <returns></returns>
        public static ONHDataHelper Instance()
        {
            if (_instance == null)
                lock (LockHelper)
                {
                    if (_instance == null)
                        _instance = new ONHDataHelper();
                }
            return _instance;
        }


        public string getONHSql(ONHData onhData)
        {
            var sql = @"
INSERT INTO PIPEOUTDEC_CHEM_PROCESS_RESULT
  (CHECK_NO,
   SAMPLE_NO,
   VALUE_TYPE,
   DEPT_ID,
   DEPT_NAME,
   DEVICE_NAME,
   ANA_O,
   ANA_N,
   ANA_H)
VALUES
  ((SELECT CHECK_NO
     FROM PIPE_CHECKCONSIGN_CHEMDETAIL
    WHERE SAMPLE_NO = '{0}'
      AND ROWNUM = 1),
   '{0}',
   2,
   '002001007010',
   '化学分析室',
   '{1}',
   {2},
   {3},
   {4})
";
            return string.Format(sql,
                onhData.SampleNo,
                onhData.DeviceName,
                string.IsNullOrWhiteSpace(onhData.OValue)
                    ? "NULL"
                    : (OFlag ? "to_char(ROUND(" + onhData.OValue + "," + ODecimals + "),'"+ (ODecimals==0?"FM999990":"FM999990.".PadRight(9+ODecimals,'0')  ) +"')" : onhData.OValue),
                string.IsNullOrWhiteSpace(onhData.NValue)
                    ? "NULL"
                    : (NFlag ? "to_char(ROUND(" + onhData.NValue + "," + NDecimals + "),'" + (NDecimals == 0 ? "FM999990" : "FM999990.".PadRight(9 + NDecimals, '0')) + "')" : onhData.NValue),
                string.IsNullOrWhiteSpace(onhData.HValue)
                    ? "NULL"
                    : (HFlag ? "to_char(ROUND(" + onhData.HValue + "," + HDecimals + "),'" + (HDecimals == 0 ? "FM999990" : "FM999990.".PadRight(9 + HDecimals, '0')) + "')" : onhData.HValue)
            );


        }

        /// <summary>
        ///     解析ONH原始数据xml文件
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="data"></param>
        public static void AnalysisXml(string FileName, out string data)
        {
            if (!File.Exists(FileName))
                throw new Exception(string.Format("文件:{0} 不存在, 传输失败", FileName));

            var rootNode = XElement.Load(FileName);
            var xElements = rootNode.Elements("analyse").ToList();
            if (xElements.Count <= 0)
                throw new Exception("找不到文件试样信息 , 传输失败");

            data = "";
            var sampleNo = "";
            if (TryGetValue(xElements[0], "sample", out sampleNo))
            {
                // MessageBox.Show(string.Format("试样号：{0}", sampleNo));
            }
            else
            {
                throw new Exception("找不到试样号信息 , 传输失败");
            }

            data = sampleNo;


            var xeResults = rootNode.Elements("results").ToList();
            var xeResultsDetail = xeResults.SelectMany(p => p.Elements("element")).ToList();


            if (xeResultsDetail.Count <= 0)
                throw new Exception("找不到试样号检验结果信息 , 传输失败");
            foreach (var dataXE in xeResultsDetail)
            {
                var Name = "";
                var Value = "";
                if (!TryGetValue(dataXE, "name", out Name))
                    throw new Exception("数据信息格式错误 , 传输失败");
                if (!TryGetValue(dataXE, "value", out Value))
                    throw new Exception("数据信息格式错误 , 传输失败");

                data = data + "," + Name + "," + Value;
            }

            data = data.ToUpper();

            var date = DateTime.Now.ToString("yyyyMMdd");
            var time = DateTime.Now.ToString("HHmmss");

            var NewPath = Environment.CurrentDirectory + "\\Log\\" + date;

            if (!Directory.Exists(NewPath))
                Directory.CreateDirectory(NewPath);

            NewPath = NewPath + "\\" + sampleNo + "__" + time + ".xml";

            File.Copy(FileName, NewPath);

            
        }

        public static bool TryGetValue(XElement ex, string elemntName, out string data)
        {
            data = "";
            try
            {
                var exList = ex.Elements(elemntName).ToList();

                if (exList.Count <= 0)
                    return false;
                data = exList[0].FirstNode.ToString();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public static void AnalysisString(string data, out ONHData ONHData)
        {
            ONHData = new ONHData();
            var datas = data.Split(',');
            if ((datas.Length < 3) || string.IsNullOrWhiteSpace(datas[0])) return;

            ONHData.SampleNo = datas[0];
            for (var i = 0; i < (datas.Length - 1)/2; i++)
            {
                double iData = 0;
                var sData = datas[2 + 2*i];
                if ((datas[1 + 2*i] == "O") && double.TryParse(sData, out iData))
                    ONHData.OValue = sData;
                if ((datas[1 + 2*i] == "N") && double.TryParse(sData, out iData))
                    ONHData.NValue = sData;
                if ((datas[1 + 2*i] == "H") && double.TryParse(sData, out iData))
                    ONHData.HValue = sData;
            }


            ONHData.Valid = true;
        }
    }
}