Kyungshin-Welder/WeldingComponents/LASA/DB/System/RecipeWeldingLines.cs

using CoreUnit.Common;
using System;
using System.Xml;
using System.Reflection;
using CoreUnit.Control.UserControl.Canvas
using System.IO;
using System.Collections.Generic;
using CoreUnit.Laser;
using System.Text.Json;


namespace DB.Recipe
{
    public class RecipeWeldingLines : Recipe
    {
        DataModel m_model;
        public DataModel Model
        {
            get { lock (this) { return m_model; } }
            set { lock (this) { m_model = value; } }
        }
        public LaserPowerCalibrationParam laserPowerCalibrationParam = new LaserPowerCalibrationParam();

        List<PowerProfile> m_powerProfiles = new List<PowerProfile>();

        public List<PowerProfile> PowerProfiles
        {
            get { lock (this) { return m_powerProfiles; } }
            set { lock (this) { m_powerProfiles = value; } }
        }

        public RecipeWeldingLines()
        {
        }

        public void Reset()
        {
        }

        public override void Save(XmlWriter wr)
        {
            try
            {
                XmlUtil.WriteProperties(this, wr);
                SaveWeldingParam(wr);
                Model.Save(wr);

                DB.Dao.IndependantListRecipe.Save();
            }
            catch (Exception ex)
            {
                UtilUnit.logUnit.SetLog(LogUnit.eLogType.ALARM, MethodBase.GetCurrentMethod().Name, ex.Message);
            }
        }

        public override string Save()
        {
            string jsonString = string.Empty;
            var options = new JsonSerializerOptions { WriteIndented = true };
            try
            {
                //jsonString = JsonSerializer.Serialize(this, options);
                jsonString += JsonSerializer.Serialize(ScannerCanvasUserCtrl.ScannerParams, options);
                jsonString += Model.Save();
                DB.Dao.IndependantListRecipe.Save();
            }
            catch (Exception ex)
            {
                UtilUnit.logUnit.SetLog(LogUnit.eLogType.ALARM, MethodBase.GetCurrentMethod().Name, ex.Message);
            }
            return jsonString;
        }

        public override void Load(XmlElement xmlElement)
        {
            try
            {
                LoadWeldingParam(xmlElement);
                Model.Load(xmlElement);

                DB.Dao.IndependantListRecipe.Load();
            }
            catch (Exception ex)
            {
                UtilUnit.logUnit.SetLog(LogUnit.eLogType.ALARM, MethodBase.GetCurrentMethod().Name, ex.Message);
            }
        }

        public override void SubLoad(string fileName)
        {
            var options = new JsonSerializerOptions() { WriteIndented = true };
            ScannerCanvasUserCtrl.ScannerParams = JsonSerializer.Deserialize<List<ScannerParam>>(fileName, options);
        }

        private void SaveWeldingParam(XmlWriter wr)
        {
            #region 1.Scanner Objects에 대한 데이터 저장
            wr.WriteStartElement("WeldingParameters");
            wr.WriteStartElement("items");
            foreach (ScannerParam param in ScannerCanvasUserCtrl.ScannerParams)
            {
                wr.WriteStartElement("WeldingParameter");
                CoreUnit.Common.XmlUtil.WriteProperties(param, wr);
                wr.WriteEndElement();
            }
            wr.WriteEndElement();
            wr.WriteEndElement();
            #endregion
        }

        private void LoadWeldingParam(XmlElement root)
        {
            try
            {
                ScannerCanvasUserCtrl.ScannerParams.Clear();

                int paramNo = 0;
                foreach (XmlElement node in root.ChildNodes)
                {
                    if (node.Name == "WeldingParameters")
                    {
                        #region 1.Scanner Objects에 대한 데이터 로딩
                        foreach (XmlElement subNode in node.ChildNodes)
                        {
                            if (subNode.Name == "items")
                            {
                                //ScannerCanvasUserCtrl.ScannerParams.Clear();

                                foreach (XmlElement itemNode in subNode.ChildNodes)
                                {
                                    ScannerParam param = new ScannerParam();
                                    CoreUnit.Common.XmlUtil.ParseProperties(itemNode, param);
                                    param.No = paramNo;
                                    paramNo++;
                                    ScannerCanvasUserCtrl.ScannerParams.Add((ScannerParam)param);
                                }
                            }
                        }
                        #endregion
                    }
                }

                if (ScannerCanvasUserCtrl.ScannerParams.Count < 128)
                {
                    CreateScannerParams();
                }

                for (int i = 0; i < ScannerCanvasUserCtrl.ScannerParams.Count; i++)
                {
                    WeldingParameterIDEditor.UpdateColorList(i, ScannerCanvasUserCtrl.ScannerParams[i].Color);
                }


            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public void CreateScannerParams()
        {
            ScannerCanvasUserCtrl.ScannerParams.Clear();

            for (int i = 0; i < 128; i++)
            {
                ScannerParam param = new ScannerParam();
                param.No = i;
                ScannerCanvasUserCtrl.ScannerParams.Add(param);
            }
        }

        private void AddPowerProfile()
        {
            PowerProfile powerProfile = new PowerProfile();
            m_powerProfiles.Add(powerProfile);
        }

        public void LoadPowerProfile(string fileName)
        {
            try
            {
                FileInfo fi = new FileInfo(fileName);

                StreamReader sr = new StreamReader(fileName);
                XmlDocument doc = new XmlDocument();
                doc.Load(sr);
                sr.Dispose();

                XmlElement root = doc.DocumentElement;

                m_powerProfiles.Clear();
                foreach (XmlElement node in root.ChildNodes)
                {
                    if (node.Name == "PowerProfile")
                    {
                        PowerProfile profile = new PowerProfile();

                        foreach (XmlElement childnode in node.ChildNodes)
                        {
                            PowerProfile.PowerProfileParam param = new PowerProfile.PowerProfileParam();

                            CoreUnit.Common.XmlUtil.ParseProperties(childnode, param);

                            profile.PowerProfileParams.Add(param);
                        }

                        m_powerProfiles.Add(profile);
                    }



                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void SavePowerProfile(string fileName)
        {
            try
            {
                XmlTextWriter wr = new XmlTextWriter(fileName, null);
                wr.Formatting = Formatting.Indented;
                wr.WriteStartElement("PowerProfileList");

                foreach (PowerProfile powerProfile in m_powerProfiles)
                {
                    wr.WriteStartElement("PowerProfile");
                    foreach(PowerProfile.PowerProfileParam param in powerProfile.PowerProfileParams)
                    {
                        wr.WriteStartElement("PowerProfileParam");
                        CoreUnit.Common.XmlUtil.WriteProperties(param, wr);
                        wr.WriteEndElement();
                    }
                    wr.WriteEndElement();
                }

                wr.WriteEndElement();

                wr.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }

}