HYTOS

<?xml version="1.0" encoding="utf-8"?>

<configuration>

  <configSections>

    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->

    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />

  </configSections>

  <entityFramework>

    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">

      <parameters>

        <parameter value="mssqllocaldb" />

      </parameters>

    </defaultConnectionFactory>

    <providers>

      <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />

      <provider invariantName="System.Data.SQLite.EF6" type="System.Data.SQLite.EF6.SQLiteProviderServices, System.Data.SQLite.EF6" />

    </providers>

  </entityFramework>

<system.data>

    <DbProviderFactories>

      <remove invariant="System.Data.SQLite.EF6" />

      <add name="SQLite Data Provider (Entity Framework 6)" invariant="System.Data.SQLite.EF6" description=".NET Framework Data Provider for SQLite (Entity Framework 6)" type="System.Data.SQLite.EF6.SQLiteProviderFactory, System.Data.SQLite.EF6" />

    <remove invariant="System.Data.SQLite" /><add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".NET Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" /></DbProviderFactories>

  </system.data></configuration>

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{BEEC4A21-BD63-40D2-B745-027B19241A70}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AppDesignerFolder>Properties</AppDesignerFolder>

    <RootNamespace>Converter.BaseModel</RootNamespace>

    <AssemblyName>BaseModel</AssemblyName>

    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <Deterministic>true</Deterministic>

    <NuGetPackageImportStamp>

    </NuGetPackageImportStamp>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">

    <DebugSymbols>true</DebugSymbols>

    <OutputPath>..\SPPIDConverterDll\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <DebugType>full</DebugType>

    <PlatformTarget>x86</PlatformTarget>

    <ErrorReport>prompt</ErrorReport>

    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">

    <OutputPath>bin\x86\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <Optimize>true</Optimize>

    <DebugType>pdbonly</DebugType>

    <PlatformTarget>x86</PlatformTarget>

    <ErrorReport>prompt</ErrorReport>

    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.dll</HintPath>

    </Reference>

    <Reference Include="EntityFramework.SqlServer, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.SqlServer.dll</HintPath>

    </Reference>

    <Reference Include="System" />

    <Reference Include="System.ComponentModel.DataAnnotations" />

    <Reference Include="System.Core" />

    <Reference Include="System.Data.SQLite, Version=1.0.111.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">

      <HintPath>..\packages\System.Data.SQLite.Core.1.0.111.0\lib\net46\System.Data.SQLite.dll</HintPath>

    </Reference>

    <Reference Include="System.Data.SQLite.EF6, Version=1.0.111.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">

      <HintPath>..\packages\System.Data.SQLite.EF6.1.0.111.0\lib\net46\System.Data.SQLite.EF6.dll</HintPath>

    </Reference>

    <Reference Include="System.Data.SQLite.Linq, Version=1.0.111.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">

      <HintPath>..\packages\System.Data.SQLite.Linq.1.0.111.0\lib\net46\System.Data.SQLite.Linq.dll</HintPath>

    </Reference>

    <Reference Include="System.Windows.Forms" />

    <Reference Include="System.Xml.Linq" />

    <Reference Include="System.Data.DataSetExtensions" />

    <Reference Include="Microsoft.CSharp" />

    <Reference Include="System.Data" />

    <Reference Include="System.Net.Http" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="Model\ChildSymbol.cs" />

    <Compile Include="Model\Equipment.cs" />

    <Compile Include="Model\SPPID\SPPIDLabelLocationInfo.cs" />

    <Compile Include="Model\TrimLine.cs" />

    <Compile Include="Model\Other\Association.cs" />

    <Compile Include="Model\Other\Attribute.cs" />

    <Compile Include="Model\Other\Connector.cs" />

    <Compile Include="Model\Other\LineNumberRun.cs" />

    <Compile Include="Model\Other\Property.cs" />

    <Compile Include="Model\SPPID\SPPIDLineInfo.cs" />

    <Compile Include="Model\SPPID\SPPIDSymbolInfo.cs" />

    <Compile Include="Model\EndBreak.cs" />

    <Compile Include="Project_DB.cs" />

    <Compile Include="Project_Info.cs" />

    <Compile Include="Model\Document.cs" />

    <Compile Include="Model\Line.cs" />

    <Compile Include="Model\LineNumber.cs" />

    <Compile Include="Model\Note.cs" />

    <Compile Include="Properties\AssemblyInfo.cs" />

    <Compile Include="Model\Symbol.cs" />

    <Compile Include="Model\Text.cs" />

  </ItemGroup>

  <ItemGroup>

    <None Include="App.config" />

    <None Include="packages.config" />

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

  <Import Project="..\packages\System.Data.SQLite.Core.1.0.111.0\build\net46\System.Data.SQLite.Core.targets" Condition="Exists('..\packages\System.Data.SQLite.Core.1.0.111.0\build\net46\System.Data.SQLite.Core.targets')" />

  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">

    <PropertyGroup>

      <ErrorText>이 프로젝트는 이 컴퓨터에 없는 NuGet 패키지를 참조합니다. 해당 패키지를 다운로드하려면 NuGet 패키지 복원을 사용하십시오. 자세한 내용은 http://go.microsoft.com/fwlink/?LinkID=322105를 참조하십시오. 누락된 파일은 {0}입니다.</ErrorText>

    </PropertyGroup>

    <Error Condition="!Exists('..\packages\System.Data.SQLite.Core.1.0.111.0\build\net46\System.Data.SQLite.Core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\System.Data.SQLite.Core.1.0.111.0\build\net46\System.Data.SQLite.Core.targets'))" />

  </Target>

</Project>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class ChildSymbol

    {

        private int _ParentAt;

        private string _Direction;

        private string _NAME;

        private List<ChildSymbol> _ChildSymbols = new List<ChildSymbol>();

        private List<Connector> _Connectors = new List<Connector>();

        private SPPIDSymbolInfo _SPPID;

        public string NAME { get => _NAME; set => _NAME = value; }

        public List<ChildSymbol> ChildSymbols { get => _ChildSymbols; set => _ChildSymbols = value; }

        public int ParentAt { get => _ParentAt; set => _ParentAt = value; }

        public string Direction { get => _Direction; set => _Direction = value; }

        public List<Connector> Connectors { get => _Connectors; set => _Connectors = value; }

        public SPPIDSymbolInfo SPPID { get => _SPPID; set => _SPPID = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.IO;

using System.Xml.Linq;

using System.Windows.Forms;

namespace Converter.BaseModel

{

    public class Document

    {

        private string _DWGNAME;

        private string _SIZE;

        private double _SIZE_WIDTH;

        private double _SIZE_HEIGHT;

        private List<Symbol> _SYMBOLS = new List<Symbol>();

        private List<Text> _TEXTINFOS = new List<Text>();

        private List<Note> _NOTES = new List<Note>();

        private List<Line> _LINES = new List<Line>();

        private List<LineNumber> _LINENUMBERS = new List<LineNumber>();

        private List<TrimLine> _TRIMLINES = new List<TrimLine>();

        private List<EndBreak> _EndBreaks = new List<EndBreak>();

        private List<Equipment> _Equipments = new List<Equipment>();

        private bool _Enable;

        public bool Enable { get { return _Enable; } }

        public List<Symbol> SYMBOLS { get => _SYMBOLS; set => _SYMBOLS = value; }

        public List<Text> TEXTINFOS { get => _TEXTINFOS; set => _TEXTINFOS = value; }

        public List<Note> NOTES { get => _NOTES; set => _NOTES = value; }

        public List<Line> LINES { get => _LINES; set => _LINES = value; }

        public List<LineNumber> LINENUMBERS { get => _LINENUMBERS; set => _LINENUMBERS = value; }

        public List<EndBreak> EndBreaks { get => _EndBreaks; set => _EndBreaks = value; }

        public List<Equipment> Equipments { get => _Equipments; set => _Equipments = value; }

        public string DWGNAME { get => _DWGNAME; set => _DWGNAME = value; }

        public string SIZE

        {

            get

            {

                return _SIZE;

            }

            set

            {

                _SIZE = value;

                string[] pointArr = _SIZE.Split(new char[] { ',' });

                if (pointArr.Length == 2)

                {

                    _SIZE_WIDTH = Convert.ToDouble(pointArr[0]);

                    _SIZE_HEIGHT = Convert.ToDouble(pointArr[1]);

                }

            }

        }

        public double SIZE_WIDTH { get => _SIZE_WIDTH; }

        public double SIZE_HEIGHT { get => _SIZE_HEIGHT; }

        public List<TrimLine> TRIMLINES { get => _TRIMLINES; set => _TRIMLINES = value; }

        public Document(string xmlPath)

        {

            try

            {

                XElement xml = XElement.Load(xmlPath);

                DWGNAME = xml.Element("DWGNAME").Value;

                SIZE = xml.Element("SIZE").Value;

                SetText(xml.Element("TEXTINFOS"));

                SetNote(xml.Element("NOTES"));

                SetSymbol(xml.Element("SYMBOLS"));

                SetLine(xml.Element("LINEINFOS"));

                SetLineNumber(xml.Element("LINENOS"));

                SetTrimLine(xml.Element("TRIMLINENOS"));

                _Enable = true;

            }

            catch (Exception ex)

            {

                _Enable = false;

                MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

            }

        }

        #region READ XML

        private void SetSymbol(XElement node)

        {

            foreach (XElement item in node.Elements("SYMBOL"))

            {

                string sType = item.Element("TYPE").Value;

                if (sType == "Segment Breaks")

                {

                    continue;

                }

                else if (sType == "End Break")

                {

                    EndBreak endBreak = new EndBreak()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), endBreak.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), endBreak.CONNECTORS, endBreak.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), endBreak.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), endBreak.ATTRIBUTES);

                    EndBreaks.Add(endBreak);

                }

                else if (sType == "Black Box System" ||

                    sType == "GGO_Equipment" ||

                    sType == "Heat Transfer Equipment" ||

                    sType == "Mechanical" ||

                    sType == "Other Equipment" ||

                    sType == "Vessels")

                {

                    Equipment equipment = new Equipment()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), equipment.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), equipment.CONNECTORS, equipment.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), equipment.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), equipment.ATTRIBUTES);

                    Equipments.Add(equipment);

                }

                else

                {

                    Symbol symbol = new Symbol()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), symbol.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), symbol.CONNECTORS, symbol.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), symbol.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), symbol.ATTRIBUTES);

                    SetChildSymbol(symbol);

                    SYMBOLS.Add(symbol);

                }

            }

        }

        private void SetLine(XElement node)

        {

            foreach (XElement item in node.Elements("LINE"))

            {

                Line line = new Line()

                {

                    OWNER = item.Attribute("OWNER").Value,

                    UID = item.Element("UID").Value,

                    STARTPOINT = item.Element("STARTPOINT").Value,

                    ENDPOINT = item.Element("ENDPOINT").Value,

                    TYPE = item.Element("TYPE").Value,

                    TYPEUID = item.Element("TYPE").Attribute("TYPEUID").Value,

                    AREA = item.Element("AREA").Value,

                    THICKNESS = item.Element("THICKNESS").Value,

                };

                SetConnectors(item.Element("CONNECTORS"), line.CONNECTORS);

                LINES.Add(line);

            }

        }

        private void SetLineNumber(XElement node)

        {

            foreach (XElement item in node.Elements("LINE_NO"))

            {

                LineNumber lineNumber = new LineNumber()

                {

                    UID = item.Element("UID").Value,

                    TEXT = item.Element("TEXT").Value,

                    LOCATION = item.Element("LOCATION").Value,

                    WIDTH = item.Element("WIDTH").Value,

                    HEIGHT = item.Element("HEIGHT").Value,

                    ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                    AREA = item.Element("AREA").Value,

                    CONNLINE = item.Element("CONNLINE").Value,

                    SCENE = item.Element("SCENE").Value

                };

                SetLineNumberRuns(item, lineNumber.RUNS);

                SetProperties(item.Element("PROPERTIES"), lineNumber.PROPERTIES);

                SetAttributes(item, lineNumber.ATTRIBUTES);

                LINENUMBERS.Add(lineNumber);

            }

        }

        private void SetText(XElement node)

        {

            foreach (XElement item in node.Elements("ATTRIBUTE"))

            {

                Text text = new Text()

                {

                    UID = item.Element("UID").Value,

                    OWNER = item.Element("OWNER").Value,

                    ATTRIBUTEVALUE = item.Element("ATTRIBUTEVALUE").Value,

                    NAME = item.Element("NAME").Value,

                    LOCATION = item.Element("LOCATION").Value,

                    VALUE = item.Element("VALUE").Value,

                    ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                    WIDTH = item.Element("WIDTH").Value,

                    HEIGHT = item.Element("HEIGHT").Value,

                    AREA = item.Element("AREA").Value,

                    SCENE = item.Element("SCENE").Value

                };

                TEXTINFOS.Add(text);

            }

        }

        private void SetNote(XElement node)

        {

            foreach (XElement item in node.Elements("ATTRIBUTE"))

            {

                Note note = new Note()

                {

                    UID = item.Element("UID").Value,

                    ATTRIBUTEVALUE = item.Element("ATTRIBUTEVALUE").Value,

                    NAME = item.Element("NAME").Value,

                    LOCATION = item.Element("LOCATION").Value,

                    VALUE = item.Element("VALUE").Value,

                    ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                    WIDTH = item.Element("WIDTH").Value,

                    HEIGHT = item.Element("HEIGHT").Value,

                    AREA = item.Element("AREA").Value,

                    SCENE = item.Element("SCENE").Value

                };

                NOTES.Add(note);

            }

        }

        private void SetTrimLine(XElement node)

        {

            foreach (XElement item in node.Elements("TRIM_LINE_NO"))

            {

                TrimLine trimLine = new TrimLine()

                {

                    UID = item.Element("UID").Value,

                };

                SetLineNumberRuns(item, trimLine.RUNS);

                TRIMLINES.Add(trimLine);

            }

        }

        private void SetAssociations(XElement node, List<Association> associations)

        {

            foreach (XElement item in node.Elements("ASSOCIATION"))

            {

                Association association = new Association()

                {

                    TYPE = item.Attribute("TYPE").Value,

                    VALUE = item.Value

                };

                Text text = _TEXTINFOS.Find(x => x.UID == association.VALUE);

                if (text != null)

                    text.ASSOCIATION = true;

                associations.Add(association);

            }

        }

        private void SetConnectors(XElement node, List<Connector> connectors)

        {

            foreach (XElement item in node.Elements("CONNECTOR"))

            {

                connectors.Add(new Connector()

                {

                    UID = item.Attribute("UID").Value,

                    CONNECTED_AT = Convert.ToInt32(item.Attribute("CONNECTED_AT").Value),

                    CONNECTEDITEM = item.Element("CONNECTEDITEM").Value,

                    CONNECTPOINT = item.Element("CONNECTPOINT").Value,

                    SCENECONNECTPOINT = item.Element("SCENECONNECTPOINT").Value,

                });

            }

        }

        private void SetSymbolConnectors(XElement node, List<Connector> connectors, string CONNECTIONPOINT)

        {

            foreach (XElement item in node.Elements("CONNECTOR"))

            {

                connectors.Add(new Connector()

                {

                    UID = item.Attribute("UID").Value,

                    CONNECTED_AT = Convert.ToInt32(item.Attribute("CONNECTED_AT").Value),

                    CONNECTEDITEM = item.Element("CONNECTEDITEM").Value,

                    CONNECTPOINT = item.Element("CONNECTPOINT").Value,

                    SCENECONNECTPOINT = item.Element("SCENECONNECTPOINT").Value,

                });

            }

        }

        private void SetProperties(XElement node, List<Property> properties)

        {

            foreach (XElement item in node.Elements("PROPERTY"))

            {

                properties.Add(new Property()

                {

                    UID = item.Attribute("UID").Value,

                    LENGTH = item.Attribute("Length").Value,

                    EXPRESSION = item.Attribute("Expression").Value,

                    DISPLAYATTRIBUTE = item.Attribute("DisplayAttribute").Value,

                    ATTRIBUTETYPE = item.Attribute("AttributeType").Value,

                    ATTRIBUTE = item.Attribute("Attribute").Value,

                    VALUE = item.Value

                });

            }

        }

        private void SetAttributes(XElement node, List<Attribute> attributes)

        {

            foreach (XElement item in node.Elements("ATTRIBUTE"))

            {

                attributes.Add(new Attribute()

                {

                    UID = item.Attribute("UID").Value,

                    LENGTH = item.Attribute("Length").Value,

                    EXPRESSION = item.Attribute("Expression").Value,

                    DISPLAYATTRIBUTE = item.Attribute("DisplayAttribute").Value,

                    ATTRIBUTETYPE = item.Attribute("AttributeType").Value,

                    ATTRIBUTE = item.Attribute("Attribute").Value,

                    ATTRAT = item.Attribute("AttrAt").Value,

                    VALUE = item.Value

                });

            }

        }

        private void SetLineNumberRuns(XElement node, List<LineRun> lineNumberRuns)

        {

            foreach (XElement item in node.Elements("RUN"))

            {

                LineRun run = new LineRun()

                {

                    TYPE = item.Attribute("TYPE").Value

                };

                foreach (XElement element in item.Elements())

                {

                    if (element.Name == "SYMBOL")

                    {

                        Symbol symbol = GetSymbolByUID(element.Element("UID").Value);

                        if (symbol == null)

                            throw new Exception(element.Element("UID").Value);

                        run.RUNITEMS.Add(symbol);

                    }

                    else if (element.Name == "LINE")

                    {

                        Line line = GetLineByUID(element.Element("UID").Value);

                        if (line == null)

                            throw new Exception(element.Element("UID").Value);

                        run.RUNITEMS.Add(line);

                    }

                }

                lineNumberRuns.Add(run);

            }

        }

        private void SetChildSymbol(Symbol symbol)

        {

            List<ChildSymbol> childList = new List<ChildSymbol>();

            if (!string.IsNullOrEmpty(symbol.CHILD) && symbol.CHILD != "None")

            {

                string[] childArray = symbol.CHILD.Split(new char[] { '/' });

                foreach (string sChild in childArray)

                {

                    string[] sChildInfo = sChild.Split(new char[] { ',' });

                    childList.Add(new ChildSymbol()

                    {

                        ParentAt = Convert.ToInt32(sChildInfo[0]),

                        Direction = sChildInfo[1],

                        NAME = sChildInfo[2]

                    });

                }

                foreach (ChildSymbol child in childList)

                {

                    if (child.ParentAt == 0)

                        symbol.ChildSymbols.Add(child);

                    else

                        childList[child.ParentAt - 1].ChildSymbols.Add(child);

                }

            }

            if (!string.IsNullOrEmpty(symbol.CONNECTIONPOINT) && symbol.CONNECTIONPOINT != "None")

            {

                // 현재 부모 Symbol에 자식 Connector까지 들어가 있음

                string[] connectionArray = symbol.CONNECTIONPOINT.Split(new char[] { '/' });

                string[] array = symbol.CONNECTIONPOINT.Split(new char[] { '/' });

                for (int i = 0; i < array.Length; i++)

                {

                    string[] arrConn = array[i].Split(new char[] { ',' });

                    int connIndex = Convert.ToInt32(arrConn[3]);

                    if (connIndex != 0)

                    {

                        childList[connIndex - 1].Connectors.Add(symbol.CONNECTORS[i]);

                        symbol.CONNECTORS[i].Index = connIndex;

                    }

                }

            }

        }

        #endregion

        public Symbol GetSymbolByUID(string uid)

        {

            return SYMBOLS.Find(x => x.UID == uid);

        }

        public Line GetLineByUID(string uid)

        {

            return LINES.Find(x => x.UID == uid);

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class EndBreak : Symbol

    {

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Equipment : Symbol

    {

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Line

    {

        private string _OWNER;

        private string _UID;

        private string _TYPEUID;

        private string _STARTPOINT;

        private string _ENDPOINT;

        private string _TYPE;

        private string _AREA;

        private string _THICKNESS;

        private List<Connector> _CONNECTORS = new List<Connector>();

        private SPPIDLineInfo _SPPID;

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        public string UID { get => _UID; set => _UID = value; }

        public string STARTPOINT { get => _STARTPOINT; set => _STARTPOINT = value; }

        public string ENDPOINT { get => _ENDPOINT; set => _ENDPOINT = value; }

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public string THICKNESS { get => _THICKNESS; set => _THICKNESS = value; }

        public List<Connector> CONNECTORS { get => _CONNECTORS; set => _CONNECTORS = value; }

        public string TYPEUID { get => _TYPEUID; set => _TYPEUID = value; }

        public SPPIDLineInfo SPPID { get => _SPPID; set => _SPPID = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class LineNumber

    {

        private string _UID;

        private string _TEXT;

        private string _LOCATION;

        private string _WIDTH;

        private string _HEIGHT;

        private double _ANGLE;

        private string _AREA;

        private string _CONNLINE;

        private string _SCENE;

        private List<LineRun> _RUNS = new List<LineRun>();

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        private SPPIDSymbolInfo _SPPID;

        public string UID { get => _UID; set => _UID = value; }

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                if (value == 1.57)

                    value = 90 * Math.PI / 180;

                else if (value == 3.14)

                    value = Math.PI;

                else if (value == 4.71)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string AREA { get => _AREA; set => _AREA = value; }

        public List<LineRun> RUNS { get => _RUNS; set => _RUNS = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

        public SPPIDSymbolInfo SPPID { get => _SPPID; set => _SPPID = value; }

        public string CONNLINE { get => _CONNLINE; set => _CONNLINE = value; }

        public string SCENE

        {

            get

            {

                return _SCENE;

            }

            set

            {

                string[] split = value.Split(',');

                X1 = Convert.ToDouble(split[0]);

                Y1 = Convert.ToDouble(split[1]);

                X2 = X1 + Convert.ToDouble(split[2]);

                Y2 = Y1 + Convert.ToDouble(split[3]);

            }

        }

        public double X1 { get; set; }

        public double X2 { get; set; }

        public double Y1 { get; set; }

        public double Y2 { get; set; }

        public SPPIDLabelLocationInfo SPPIDLabelLocation { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Note

    {

        private string _UID;

        private string _ATTRIBUTEVALUE;

        private string _NAME;

        private string _LOCATION;

        private string _VALUE;

        private double _ANGLE;

        private string _WIDTH;

        private string _HEIGHT;

        private string _AREA;

        private string _SCENE;

        private SPPIDSymbolInfo _SPPID;

        public string UID { get => _UID; set => _UID = value; }

        public string ATTRIBUTEVALUE { get => _ATTRIBUTEVALUE; set => _ATTRIBUTEVALUE = value; }

        public string NAME { get => _NAME; set => _NAME = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                if (value == 1.57)

                    value = 90 * Math.PI / 180;

                else if (value == 3.14)

                    value = Math.PI;

                else if (value == 4.71)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public SPPIDSymbolInfo SPPID { get => _SPPID; set => _SPPID = value; }

        public string SCENE

        {

            get

            {

                return _SCENE;

            }

            set

            {

                string[] split = value.Split(',');

                X1 = Convert.ToDouble(split[0]);

                Y1 = Convert.ToDouble(split[1]);

                X2 = X1 + Convert.ToDouble(split[2]);

                Y2 = Y1 + Convert.ToDouble(split[3]);

            }

        }

        public double X1 { get; set; }

        public double X2 { get; set; }

        public double Y1 { get; set; }

        public double Y2 { get; set; }

        public SPPIDLabelLocationInfo SPPIDLabelLocation { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Association

    {

        private string _TYPE;

        private string _VALUE;

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Attribute

    {

        private string _UID;

        private string _LENGTH;

        private string _EXPRESSION;

        private string _DISPLAYATTRIBUTE;

        private string _ATTRIBUTETYPE;

        private string _ATTRIBUTE;

        private string _VALUE;

        private string _ATTRAT;

        public string UID { get => _UID; set => _UID = value; }

        public string LENGTH { get => _LENGTH; set => _LENGTH = value; }

        public string EXPRESSION { get => _EXPRESSION; set => _EXPRESSION = value; }

        public string DISPLAYATTRIBUTE { get => _DISPLAYATTRIBUTE; set => _DISPLAYATTRIBUTE = value; }

        public string ATTRIBUTETYPE { get => _ATTRIBUTETYPE; set => _ATTRIBUTETYPE = value; }

        public string ATTRIBUTE { get => _ATTRIBUTE; set => _ATTRIBUTE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        public string ATTRAT { get => _ATTRAT; set => _ATTRAT = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Connector

    {

        private string _UID;

        private int _CONNECTED_AT;

        private string _CONNECTEDITEM;

        private string _CONNECTPOINT;

        private string _SCENECONNECTPOINT;

        public string UID { get => _UID; set => _UID = value; }

        public int CONNECTED_AT { get => _CONNECTED_AT; set => _CONNECTED_AT = value; }

        public string CONNECTEDITEM { get => _CONNECTEDITEM; set => _CONNECTEDITEM = value; }

        public string CONNECTPOINT { get => _CONNECTPOINT; set => _CONNECTPOINT = value; }

        public string SCENECONNECTPOINT { get => _SCENECONNECTPOINT; set => _SCENECONNECTPOINT = value; }

        public int Index { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class LineRun

    {

        private string _TYPE;

        private List<object> _RUNITEMS = new List<object>();

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public List<object> RUNITEMS { get => _RUNITEMS; set => _RUNITEMS = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Property

    {

        private string _UID;

        private string _LENGTH;

        private string _EXPRESSION;

        private string _DISPLAYATTRIBUTE;

        private string _ATTRIBUTETYPE;

        private string _ATTRIBUTE;

        private string _VALUE;

        public string UID { get => _UID; set => _UID = value; }

        public string LENGTH { get => _LENGTH; set => _LENGTH = value; }

        public string EXPRESSION { get => _EXPRESSION; set => _EXPRESSION = value; }

        public string DISPLAYATTRIBUTE { get => _DISPLAYATTRIBUTE; set => _DISPLAYATTRIBUTE = value; }

        public string ATTRIBUTETYPE { get => _ATTRIBUTETYPE; set => _ATTRIBUTETYPE = value; }

        public string ATTRIBUTE { get => _ATTRIBUTE; set => _ATTRIBUTE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class SPPIDLabelLocationInfo

    {

        public double X1 { get; set; }

        public double X2 { get; set; }

        public double Y1 { get; set; }

        public double Y2 { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class SPPIDLineInfo

    {

        public string MAPPINGNAME { get; set; }

        public double START_X { get; set; }

        public double START_Y { get; set; }

        public double END_X { get; set; }

        public double END_Y { get; set; }

        public string ModelItemId { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class SPPIDSymbolInfo

    {

        public string MAPPINGNAME { get; set; }

        public double ORIGINAL_X { get; set; }

        public double ORIGINAL_Y { get; set; }

        public string RepresentationId { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Symbol

    {

        private string _UID;

        private string _DBUID;

        private string _NAME;

        private List<Association> _ASSOCIATIONS = new List<Association>();

        private string _TYPE;

        private string _OWNER;

        private string _ORIGINALPOINT;

        private List<Connector> _CONNECTOR = new List<Connector>();

        private string _CONNECTIONPOINT;

        private string _LOCATION;

        private string _SIZE;

        private double _ANGLE;

        private string _PARENT;

        private string _CHILD;

        private string _HASINSTRUMENTLABEL;

        private string _AREA;

        private int _FLIP;

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        private int _CURRENTPOINTMODEINDEX;

        private List<ChildSymbol> _ChildSymbols = new List<ChildSymbol>();

        private SPPIDSymbolInfo _SPPID;

        public string UID { get => _UID; set => _UID = value; }

        public string NAME { get => _NAME; set => _NAME = value; }

        public List<Association> ASSOCIATIONS { get => _ASSOCIATIONS; set => _ASSOCIATIONS = value; }

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        public string ORIGINALPOINT { get => _ORIGINALPOINT; set => _ORIGINALPOINT = value; }

        public List<Connector> CONNECTORS { get => _CONNECTOR; set => _CONNECTOR = value; }

        public string CONNECTIONPOINT { get => _CONNECTIONPOINT; set => _CONNECTIONPOINT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string SIZE { get => _SIZE; set => _SIZE = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                if (value == 1.57)

                    value = 90 * Math.PI / 180;

                else if (value == 3.14)

                    value = Math.PI;

                else if (value == 4.71)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string PARENT { get => _PARENT; set => _PARENT = value; }

        public string CHILD { get => _CHILD; set => _CHILD = value; }

        public string HASINSTRUMENTLABEL { get => _HASINSTRUMENTLABEL; set => _HASINSTRUMENTLABEL = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public int FLIP { get => _FLIP; set => _FLIP = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

        public int CURRENTPOINTMODEINDEX { get => _CURRENTPOINTMODEINDEX; set => _CURRENTPOINTMODEINDEX = value; }

        public List<ChildSymbol> ChildSymbols { get => _ChildSymbols; set => _ChildSymbols = value; }

        public string DBUID { get => _DBUID; set => _DBUID = value; }

        public SPPIDSymbolInfo SPPID { get => _SPPID; set => _SPPID = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class Text

    {

        private string _UID;

        private string _OWNER;

        private string _ATTRIBUTEVALUE;

        private string _NAME;

        private string _LOCATION;

        private string _VALUE;

        private double _ANGLE;

        private string _WIDTH;

        private string _HEIGHT;

        private string _AREA;

        private string _SCENE;

        private SPPIDSymbolInfo _SPPID;

        private bool _ASSOCIATION;

        public string UID { get => _UID; set => _UID = value; }

        public string ATTRIBUTEVALUE { get => _ATTRIBUTEVALUE; set => _ATTRIBUTEVALUE = value; }

        public string NAME { get => _NAME; set => _NAME = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                if (value == 1.57)

                    value = 90 * Math.PI / 180;

                else if (value == 3.14)

                    value = Math.PI;

                else if (value == 4.71)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public SPPIDSymbolInfo SPPID { get => _SPPID; set => _SPPID = value; }

        public bool ASSOCIATION { get => _ASSOCIATION; set => _ASSOCIATION = value; }

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        public string SCENE

        {

            get

            {

                return _SCENE;

            }

            set

            {

                string[] split = value.Split(',');

                X1 = Convert.ToDouble(split[0]);

                Y1 = Convert.ToDouble(split[1]);

                X2 = X1 + Convert.ToDouble(split[2]);

                Y2 = Y1 + Convert.ToDouble(split[3]);

            }

        }

        public double X1 { get; set; }

        public double X2 { get; set; }

        public double Y1 { get; set; }

        public double Y2 { get; set; }

        public SPPIDLabelLocationInfo SPPIDLabelLocation { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Converter.BaseModel

{

    public class TrimLine

    {

        private string _UID;

        private string _TEXT;

        private string _LOCATION;

        private string _WIDTH;

        private string _HEIGHT;

        private double _ANGLE;

        private string _AREA;

        private List<LineRun> _RUNS = new List<LineRun>();

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        public string UID { get => _UID; set => _UID = value; }

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public double ANGLE { get => _ANGLE; set => _ANGLE = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public List<LineRun> RUNS { get => _RUNS; set => _RUNS = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Globalization;

using System.Data.SQLite;

using System.Data;

namespace Converter.BaseModel

{

    public class Project_DB

    {

        const string SPPID_DB_INFO_TABLE = "T_SPPID_CONNECTION_INFO";

        const string SPPID_SYMBOL_MAPPING_TABLE = "T_SPPID_SYMBOL_MAPPING";

        const string SPPID_ATTRIBUTE_MAPPING_TABLE = "T_SPPID_ATTRIBUTE_MAPPING";

        const string SPPID_ETC_SETTING_TABLE = "T_SPPID_ETC_SETTING_TABLE";

        const string SPPID_LABEL_LOCATION_TABLE = "T_SPPID_LABEL_LOCATION";

        const string LineProperties_TABLE = "LineProperties";

        const string LineTypes_TABLE = "LineTypes";

        const string SymbolType_TABLE = "SymbolType";

        const string SymbolAttribute_TABLE = "SymbolAttribute";

        const string Symbol_TABLE = "Symbol";

        public static bool ConnTestAndCreateTable()

        {

            bool result = false;

            Project_Info projectInfo = Project_Info.GetInstance();

            SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, @"Data Source = {0}", projectInfo.DBFilePath));

            try

            {

                connection.Open();

                if (connection.State == ConnectionState.Open)

                {

                    CreateTable(connection);

                    result = true;

                }

                connection.Close();

            }

            catch (Exception ex)

            {

            }

            finally

            {

                connection.Dispose();

            }

            return result;

        }

        public static bool SaveSPPID_DB_INFO(string jsonString)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("DELETE FROM {0}", SPPID_DB_INFO_TABLE);

                        cmd.ExecuteNonQuery();

                        cmd.CommandText = string.Format("INSERT INTO {0} VALUES (@jsonString)", SPPID_DB_INFO_TABLE);

                        cmd.Parameters.AddWithValue("@jsonString", jsonString);

                        cmd.ExecuteNonQuery();

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static DataTable SelectSPPID_DB_INFO()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_DB_INFO_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static bool SaveETCSetting(string jsonString)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("DELETE FROM {0}", SPPID_ETC_SETTING_TABLE);

                        cmd.ExecuteNonQuery();

                        cmd.CommandText = string.Format("INSERT INTO {0} VALUES (@jsonString)", SPPID_ETC_SETTING_TABLE);

                        cmd.Parameters.AddWithValue("@jsonString", jsonString);

                        cmd.ExecuteNonQuery();

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static DataTable SelectETCSetting()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_ETC_SETTING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        private static void CreateTable(SQLiteConnection connection)

        {

            using (SQLiteCommand cmd = connection.CreateCommand())

            {

                cmd.CommandText = "SELECT NAME FROM sqlite_master WHERE type='table'";

                using (SQLiteDataReader dr = cmd.ExecuteReader())

                using (DataTable dt = new DataTable())

                {

                    dt.Load(dr);

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_DB_INFO_TABLE)).Length == 0)

                    {