using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Janus.Windows.GridEX.Export;
using Janus.Windows.GridEX;
using System.IO;
using System.Drawing;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Data;
using System.Collections;

namespace IControls_FireManager
{
    // 엑셀 관련 함수는 여기 클래스에서 전담한다
    public static class _Excel
    {
        // 엑셀 파일 저장용 다이얼로그  
        public static SaveFileDialog SaveFileDialog_Xls = null;
        public static GridEXExporter GridEXExporter_Xls = null;

        // Export 전용 폰트
        public static Font Export_Font = new System.Drawing.Font("굴림", 9F);

        // 디버깅 용도
        public static int Debug_Row = 0;
        public static int Debug_Col = 0;
        public static string Debug_SheetName = null;
        public static string Debug_EtcMessage = null;

        // Export (다이얼로그 창 없이 바로 생성)        
        public static EXCEL_DOC_TYPE Export_File_Check(string FileFullPath)
        {
            // Export 전용 Com 생성
            GridEXExporter_Xls = new GridEXExporter();

            string Ext = FileFullPath.Substring(FileFullPath.LastIndexOf(".") + 1, FileFullPath.Length - FileFullPath.LastIndexOf(".") - 1);
            Ext = Ext.ToLower();

            if (Ext.Equals("xls"))
            {
                return EXCEL_DOC_TYPE.Xls;
            }
            else if (Ext.Equals("xlsx"))
            {
                return EXCEL_DOC_TYPE.Xlsx;
            }
            else
            {
                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.FailFormatInform, 0);
                return EXCEL_DOC_TYPE.Not;
            }
        }

        // Export        
        public static void Export(GridEX Gridex, string FileFullPath, string Sheetname, string Caption)
        {
            // Export 전용 Com 생성
            GridEXExporter_Xls = new GridEXExporter();

            // 파일 경로 
            string filefullpath = null;

            ///
            /// 파일명이 없다는 것은 다이얼로그 창으로로 직접 파일명을 지정하겠다는 의미이다
            ///

            if (FileFullPath == null)
            {
                // 다이얼로그 생성
                SaveFileDialog_Xls = new SaveFileDialog();
                // 확장자 넣기
                SaveFileDialog_Xls.Filter = "(*.xls)|*.xls|(*.xml)|*.xml";
                // 파일 세이브 다이얼로그
                if (SaveFileDialog_Xls.ShowDialog() == DialogResult.OK)
                    filefullpath = SaveFileDialog_Xls.FileName;
            }
            else
            {
                filefullpath = FileFullPath;
            }

            ///
            /// 파일 포맷이 정확한지 알아본다
            /// 

            if (filefullpath == null || filefullpath.Length == 0)
                return;
            else if (Export_File_Check(filefullpath) == EXCEL_DOC_TYPE.Not)
                return;
            ///
            /// 사전 작업
            /// 

            // 원본 폰트 저장
            Font OriginalFont = Gridex.Font;

            // 파일 읽기
            FileStream gFile = new FileStream(filefullpath, FileMode.Create, FileAccess.ReadWrite);

            ///
            /// 엑셀파일 전용 모드 변경
            ///

            if (Caption != null)
            {
                Gridex.RootTable.TableHeader = Janus.Windows.GridEX.InheritableBoolean.True;
                Gridex.RootTable.Caption = Caption;
            }
            Gridex.Font = Export_Font;

            ///
            /// 파일 속성 지정
            /// 

            GridEXExporter_Xls.GridEX = Gridex;
            GridEXExporter_Xls.SheetName = Sheetname;
            GridEXExporter_Xls.Export(gFile);

            ///
            /// 엑셀파일 전용 모드 해제
            ///

            if (Caption != null)
            {
                Gridex.RootTable.TableHeader = Janus.Windows.GridEX.InheritableBoolean.False;
            }
            Gridex.RootTable.Caption = null;
            Gridex.Font = OriginalFont;
        }

        // 엑셀 커넥션 스트링
        public static string ConnectionString(string FileFullPath)
        {
            string result = null;
            switch (Export_File_Check(FileFullPath))
            {
                case EXCEL_DOC_TYPE.Xls:
                    result = @"Provider=Microsoft.Jet.OLEDB.4.0;Data source=" + FileFullPath + ";Extended Properties='Excel 8.0;HDR=No;IMEX=1';Persist Security Info=False";
                    break;
                case EXCEL_DOC_TYPE.Xlsx:
                    result = @"Provider=Microsoft.ACE.OLEDB.12.0;Data source=" + FileFullPath + ";Extended Properties='Excel 12.0;HDR=No;IMEX=1';Persist Security Info=False";
                    break;
            }
            return result;
        }

        // 테스트  
        public static bool OpenTest(string FileFullPath)
        {
            try
            {
                OleDbConnection Connection = new OleDbConnection(ConnectionString(FileFullPath));
                Connection.Open();
                return true;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        // 코드 시트에 있는 값을 읽어오는 함수
        // 행단위로 검색하되 공백이 나오면 더이상 읽지 않도록 한다
        // 참고로 Col 을 지정하여 열에 접근할수 있도록 한다
        public static ArrayList Get_CodeData_Until_Null(DataSet Ds, int StartRow, int FixedCol)
        {
            // 결과
            ArrayList result = new ArrayList();
            try
            {
                // 시작행
                int Count = StartRow;
                // 널값이 나올때까지 
                while (Ds.Tables[0].Rows[Count][FixedCol] != null && Ds.Tables[0].Rows[Count][FixedCol].ToString() != "null"
                    && Ds.Tables[0].Rows[Count][FixedCol].ToString().Length != 0)
                {
                    // 선후공백은 제거한다
                    string data = Ds.Tables[0].Rows[Count][FixedCol].ToString();
                    data = data.Trim();
                    result.Add(data);
                    Count++;
                }
                return result;
            }
            catch
            {
                return result;
            }
        }

        //

        // 그룹 및 맵 정보를 가져오는 함수
        // 행단위로 검색하되 지정한 총개수만큼만 가져오도록 한다
        public static ArrayList Get_CodeData_Until_AllCnt(DataSet Ds, int StartRow, int FixedCol, int AllCnt)
        {
            // 결과
            ArrayList result = new ArrayList();
            // 시작행
            int Count = StartRow;
            // 지정한 카운트 만큼
            while (Ds.Tables[0].Rows[Count][FixedCol] != null
                && Ds.Tables[0].Rows[Count][FixedCol].ToString().Length != 0)
            {
                // 선후공백은 제거한다
                string data = Ds.Tables[0].Rows[Count][FixedCol].ToString();
                data = data.Trim();
                result.Add(data);
                Count++;
                if (Count >= AllCnt + StartRow) break;
            }
            return result;
        }

        // $ 가 없는지 체크하는 함수
        public static bool CheckSheetName_Character(string SheetName)
        {
            string temp = SheetName;
            temp = temp.Replace("$", "");
            if (temp.Length == SheetName.Length)
                return false; // $ 가 없다!
            else
                return true;
        }

        // $ 뒤에 글자가 있는지 확인 (단 ' 를 제외하고)
        public static bool CheckSheetName_Character_After(string SheetName)
        {
            string[] temp = null;
            temp = SheetName.Split('$');
            if (temp.Length != 2) // 앞에서 $가 반드시 존재하는 조건을 걸었으므로 반드시 2개가 나온다 
                return false;
            else if (temp.Length == 2 && (temp[1] == "'" || temp[1] == "")) // 2개로 쪼개지지만 끝은 '  혹은 공백이다
                return true;
            else
                return false;
        }

        // 시트명 중복을 제외시키는 함수 
        public static bool CheckSheetName_SameData(string SheetName)
        {
            foreach (_Excel_Sheet Excel_Sheet in _Data.List_ExcelPoint)
            {
                if (Excel_Sheet.Sheet_Name == SheetName)
                    return false;
            }
            return true;
        }

        // 시트명 예외처리..
        // 원래는 정확한 데이타가 들어와야 하지만 예외처리 조건이 너무 많다..테스트 결과 몇가지 규칙을 알아내었다.. 2013.04.19
        // 1. 시트명에는 반드시 뒤에 $가 들어온다
        // 2. 숫자로 시작되는 시트명에는 작은따옴표가 앞뒤로 붙는다 -> '101동$'  
        // 3. 영문 혹은 한글로 시작되는 시트명에는 작은따옴표가 없다 -> 주차장$
        // 4. 특수문자 혹은 공백으로 시작되는 시트명에는 작은따옴표가 앞뒤로 붙는다 -> ' 101동$' , '@101동$'
        // 5. '101동'$Print_Area 와 같이 뒤에 이상한 문자열이 따르는 경우가 있다
        // 6. 주차장1$Print_Titles 와 같이 뒤에 이상한 문자열이 따르는 경우가 있다.
        // 
        // 처리방법은 다음과 같다
        // 1. 특별 제외는 2개이다. 수량$,코드$ 는 엑셀포맷에 있지만 읽을수 없는 내용이므로 제외시킨다.
        // 2. $가 없다면 시트명이 아니다
        // 3. $뒤에 글자가 있는 것은 시트명이 아니다 (단, ' 를 제외하고)
        // 4. 한번 읽었던 시트명은 더 읽을수가 없다 (즉, 중복처리)
        // 5. 따옴표가 있든 없는 읽은 값을 그대로 사용하면 된다.        
        public static bool Import_Point_CheckSheetName(string SheetName)
        {
            // 수량$, 코드$는 읽을수 없다
            if (SheetName == "수량$"
                || SheetName == "코드$"
                || SheetName == "연동그룹$"
                || SheetName == "연동설정$"
                )
                return false;
            // $가 없다면 시트명이 아니다
            else if (CheckSheetName_Character(SheetName) == false)
                return false;
            // $ 뒤에 글자가 있는건 시트명이 아니다
            else if (CheckSheetName_Character_After(SheetName) == false)
                return false;
            // 중복처리
            else if (CheckSheetName_SameData(SheetName) == false)
                return false;
            else
                return true;
        }

        // 위치 데이타를 토대로 클래스에 사용될 위치 이름 생성
        public static string Code_Position_Name_Create(string BuildingName, string StairName, string FloorName)
        {
            // 모두 None 값이라면 수신기로 대체
            if (BuildingName == _Text.None && StairName == _Text.None && FloorName == _Text.None) return "수신기";

            string TempResultPostionName = null;
            // 빌딩 : None 은 언급하지 않는다
            if (BuildingName != _Text.None) TempResultPostionName = BuildingName;
            // 공백처리
            if (TempResultPostionName != null) TempResultPostionName = TempResultPostionName.Trim();
            // 층 : None 은 언급하지 않는다
            if (StairName != _Text.None) TempResultPostionName = TempResultPostionName + _Text.Blank + StairName;
            // 공백처리
            if (TempResultPostionName != null) TempResultPostionName = TempResultPostionName.Trim();
            // 계단 : None 은 언급하지 않는다
            if (FloorName != _Text.None) TempResultPostionName = TempResultPostionName + _Text.Blank + FloorName;
            // 공백처리
            if (TempResultPostionName != null) TempResultPostionName = TempResultPostionName.Trim();
            // 모두 공백이라면 None 으로 처리한다
            if (TempResultPostionName == null) TempResultPostionName = _Text.None;
            return TempResultPostionName;
        }

        // 이름으로 해쉬테이블에 조회해서 있다면 사용여부 변수를 true 변환
        public static bool Code_Position_Enable_Check(string CodePosition_Name)
        {
            if (_Data.HASH_CodePosition.ContainsKey(CodePosition_Name) == true)
            {
                // 사용여부 
                ((_Code_Position)_Data.HASH_CodePosition[CodePosition_Name]).Enable = true;
                return true;
            }
            return false;
        }

        // 사용여부를 토대로 나머지는 모두 지워버림
        public static void Code_Postion_Create()
        {
            // 결과를 저장
            Hashtable Result_HASH_CodePosition = new Hashtable();
            ArrayList Result_LIST_CodePosition_NAME = new ArrayList();

            foreach (string CodePosition_NAME in _Data.LIST_CodePosition_NAME)
            {
                // cyim 2013.6.20 코드정보는 사용을 하든 안하든 무조건 추가하도록 만든다, 다만 중복은 허용하지 않도록 만든다
                // cyim 2013.6.26 FPER 에서 로딩속도가 너무 오래걸리므로 일단 사용하는것으로만 처리한다
                if (((_Code_Position)_Data.HASH_CodePosition[CodePosition_NAME]).Enable == true)
                {
                    // 중복허용안함
                    if (Result_LIST_CodePosition_NAME.Contains(CodePosition_NAME) == false)
                    {
                        // 해쉬에 추가
                        Result_HASH_CodePosition.Add(CodePosition_NAME, ((_Code_Position)_Data.HASH_CodePosition[CodePosition_NAME]));
                        // 리스트에 추가
                        Result_LIST_CodePosition_NAME.Add(CodePosition_NAME);
                    }
                }
            }
            // 사용여부가 true 인것만 저장함
            _Data.HASH_CodePosition = Result_HASH_CodePosition;
            _Data.LIST_CodePosition_NAME = Result_LIST_CodePosition_NAME;
        }


        // 코드값 읽기
        public static bool Import_Point_GetCode(DataTable Sheets, OleDbConnection Connection)
        {
            try
            {
                // 코드 시트명을 가져온다                 
                for (int i = 0; i < Sheets.Rows.Count; i++)
                {
                    // 만약 가져오지 못한다면 실패로 처리함, 코드 시트명은 고정되어 있다! => 코드$ 
                    if (Sheets.Rows[i]["TABLE_NAME"].ToString() == "코드$")
                    {
                        // 시트명
                        string sheetname = Sheets.Rows[i]["TABLE_NAME"].ToString();

                        OleDbCommand Command = new OleDbCommand("Select * From [코드$]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// 코드값들을 읽는다
                        ///

                        // 건물 이름
                        ArrayList List_Building_Name = new ArrayList();
                        ArrayList List_Building_Position = new ArrayList();
                        ArrayList List_Building_Emergency = new ArrayList();
                        // 계단
                        ArrayList List_Stair_Name = new ArrayList();
                        ArrayList List_Stair_Position = new ArrayList();
                        ArrayList List_Stair_Emergency = new ArrayList();
                        // 층
                        ArrayList List_Floor_Name = new ArrayList();
                        ArrayList List_Floor_Position = new ArrayList();
                        ArrayList List_Floor_Emergency = new ArrayList();
                        // 입력
                        ArrayList List_Input_TypeName = new ArrayList();
                        // 출력
                        ArrayList List_Output_TypeName = new ArrayList();
                        ArrayList List_Output_SEQ = new ArrayList();
                        ArrayList List_Output_USE = new ArrayList();
                        // IO 보드
                        ArrayList List_IOBoard_Name = new ArrayList();
                        ArrayList List_IOBoard_ComPort = new ArrayList();
                        ArrayList List_IOBoard_BoardID = new ArrayList();
                        ArrayList List_IOBoard_LoopNo = new ArrayList();
                        ArrayList List_IOBoard_RepeaterID = new ArrayList();
                        ArrayList List_IOBoard_DeviceID = new ArrayList();
                        ArrayList List_IOBoard_InOut = new ArrayList();
                        ArrayList List_IOBoard_AddRepeaterYesNo = new ArrayList();
                        ArrayList List_IOBoard_AddRepeaterType = new ArrayList();
                        // 이벤트 타입
                        ArrayList List_EventType_Type = new ArrayList();
                        ArrayList List_EventType_Name = new ArrayList();
                        // 아날로그 감지기 레벨 및 시간
                        ArrayList List_Analog_Level_Smoke = new ArrayList();    // cyim 2016.07.27 : 아날로그 감지기 레벨 감지기 타입별 설정 기능
                        ArrayList List_Analog_Level_Heat = new ArrayList();
                        ArrayList List_FireDay_Time = new ArrayList();

                        // 건물코드 읽기
                        List_Building_Name = Get_CodeData_Until_Null(ds, 3, 0);
                        List_Building_Position = Get_CodeData_Until_Null(ds, 3, 1);
                        List_Building_Emergency = Get_CodeData_Until_Null(ds, 3, 2);
                        // 계단코드 읽기
                        List_Stair_Name = Get_CodeData_Until_Null(ds, 3, 3);
                        List_Stair_Position = Get_CodeData_Until_Null(ds, 3, 4);
                        List_Stair_Emergency = Get_CodeData_Until_Null(ds, 3, 5);
                        // 층코드 읽기
                        List_Floor_Name = Get_CodeData_Until_Null(ds, 3, 6);
                        List_Floor_Position = Get_CodeData_Until_Null(ds, 3, 7);
                        List_Floor_Emergency = Get_CodeData_Until_Null(ds, 3, 8);
                        // 입력코드 읽기 
                        List_Input_TypeName = Get_CodeData_Until_Null(ds, 3, 10);
                        // 출력코드 읽기
                        List_Output_TypeName = Get_CodeData_Until_Null(ds, 3, 12);
                        List_Output_SEQ = Get_CodeData_Until_Null(ds, 3, 13);
                        List_Output_USE = Get_CodeData_Until_Null(ds, 3, 14);
                        // IO 보드 읽기
                        List_IOBoard_Name = Get_CodeData_Until_Null(ds, 3, 18);
                        List_IOBoard_ComPort = Get_CodeData_Until_Null(ds, 3, 19);
                        List_IOBoard_BoardID = Get_CodeData_Until_Null(ds, 3, 20);
                        List_IOBoard_LoopNo = Get_CodeData_Until_Null(ds, 3, 21);
                        List_IOBoard_RepeaterID = Get_CodeData_Until_Null(ds, 3, 22);
                        List_IOBoard_DeviceID = Get_CodeData_Until_Null(ds, 3, 23);
                        List_IOBoard_InOut = Get_CodeData_Until_Null(ds, 3, 24);
                        List_IOBoard_AddRepeaterYesNo = Get_CodeData_Until_Null(ds, 3, 25);
                        List_IOBoard_AddRepeaterType = Get_CodeData_Until_Null(ds, 3, 26);
                        // 이벤트 타입 읽기
                        List_EventType_Type = Get_CodeData_Until_Null(ds, 3, 28);
                        List_EventType_Name = Get_CodeData_Until_Null(ds, 3, 29);
                        // 아날로그 감지기 레벨 및 시간
                        List_Analog_Level_Smoke = Get_CodeData_Until_Null(ds, 3, 32);
                        List_Analog_Level_Heat = Get_CodeData_Until_Null(ds, 12, 32);    // cyim 2016.07.27 : 아날로그 감지기 레벨 감지기 타입별 설정 기능                   
                        List_FireDay_Time = Get_CodeData_Until_Null(ds, 3, 34);

                        // 단, 코드 값중에 하나라도 빈값이라면 취소
                        if (List_Building_Name.Count == 0 || List_Building_Position.Count == 0 || List_Building_Emergency.Count == 0
                            || List_Stair_Name.Count == 0 || List_Stair_Position.Count == 0 || List_Stair_Emergency.Count == 0
                            || List_Floor_Name.Count == 0 || List_Floor_Position.Count == 0 || List_Floor_Emergency.Count == 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError1, 0);
                            return false;
                        }
                        if (List_Input_TypeName.Count == 0 || List_Output_TypeName.Count == 0 || List_Output_SEQ.Count == 0 || List_Output_USE.Count == 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError7, 0);
                            return false;
                        }
                        if (List_IOBoard_Name.Count == 0 || List_IOBoard_ComPort.Count == 0 || List_IOBoard_BoardID.Count == 0
                            || List_IOBoard_LoopNo.Count == 0 || List_IOBoard_RepeaterID.Count == 0 || List_IOBoard_DeviceID.Count == 0
                            || List_IOBoard_InOut.Count == 0 || List_IOBoard_AddRepeaterYesNo.Count == 0 || List_IOBoard_AddRepeaterYesNo.Count == 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError8, 0);
                            return false;
                        }
                        if (List_EventType_Type.Count == 0 || List_EventType_Name.Count == 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError9, 0);
                            return false;
                        }

                        //
                        // 단, 코드의 3가지는 모두 개수가 동일해야한다. 또한 출력코드 및 IO 보드 및 이벤트 타입은 데이타 레코드수가 동일해야한다
                        //

                        if ((List_Building_Name.Count != List_Building_Position.Count) || (List_Building_Name.Count != List_Building_Emergency.Count))
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError2, 0);
                            return false;
                        }
                        if ((List_Stair_Name.Count != List_Stair_Position.Count) || (List_Stair_Name.Count != List_Stair_Emergency.Count))
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError2, 0);
                            return false;
                        }
                        if ((List_Floor_Name.Count != List_Floor_Position.Count) || (List_Floor_Name.Count != List_Floor_Emergency.Count))
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError2, 0);
                            return false;
                        }
                        if (List_Output_TypeName.Count + List_Output_SEQ.Count + List_Output_USE.Count != List_Output_TypeName.Count * 3)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError4, 0);
                            return false;
                        }
                        if (List_IOBoard_Name.Count + List_IOBoard_ComPort.Count + List_IOBoard_BoardID.Count + List_IOBoard_LoopNo.Count + List_IOBoard_RepeaterID.Count
                            + List_IOBoard_DeviceID.Count + List_IOBoard_InOut.Count + List_IOBoard_AddRepeaterYesNo.Count + List_IOBoard_AddRepeaterType.Count != List_IOBoard_Name.Count * 9)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError5, 0);
                            return false;
                        }
                        if (List_EventType_Type.Count != List_EventType_Name.Count)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError6, 0);
                            return false;
                        }

                        ///
                        /// 데이타베이스 연동을 위한 클래스를 생성한다
                        ///

                        // 위치코드 및 비상코드를 생성한다 (건물-계단-층 순으로 고유의 6자리 코드를 생성한다
                        // 또한 여기에 명칭을 정리한다. 이 경우에 공백으로 각 데이타를 구분하도록 한다
                        // ex : 101동 - 1계단 - None => 101동 1계단
                        // ex : 101동 - None - B1F => 101동 B1F

                        _Data.HASH_CodePosition.Clear();
                        _Data.LIST_CodePosition_NAME.Clear();

                        foreach (string BuildingName in List_Building_Name)
                        {
                            foreach (string StairName in List_Stair_Name)
                            {
                                foreach (string FloorName in List_Floor_Name)
                                {
                                    // 클래스 생성
                                    _Code_Position Code_Position = new _Code_Position();

                                    ///
                                    /// 아이디
                                    ///

                                    //Code_Position.Code_Position_ID = 
                                    //    _Convert.String_to_Int_TwoType(List_Building.IndexOf(BuildingName).ToString()) +
                                    //    _Convert.String_to_Int_TwoType(List_Stair.IndexOf(StairName).ToString()) +
                                    //    _Convert.String_to_Int_TwoType(List_Floor.IndexOf(FloorName).ToString());

                                    // 인덱스는 동일하므로 
                                    int Temp_Index_Building = List_Building_Name.IndexOf(BuildingName);
                                    int Temp_Index_Stair = List_Stair_Name.IndexOf(StairName);
                                    int Temp_Index_Floor = List_Floor_Name.IndexOf(FloorName);

                                    ///
                                    /// 위치코드
                                    ///

                                    Code_Position.Code_Position_ID =
                                            _Convert.String_to_Int_TwoType(List_Building_Position[Temp_Index_Building].ToString()) +
                                            _Convert.String_to_Int_TwoType(List_Stair_Position[Temp_Index_Stair].ToString()) +
                                            _Convert.String_to_Int_TwoType(List_Floor_Position[Temp_Index_Floor].ToString());

                                    ///
                                    /// 비상방송코드
                                    ///

                                    Code_Position.Code_Emergency_ID =
                                            _Convert.String_to_Int_TwoType(List_Building_Emergency[Temp_Index_Building].ToString()) +
                                            _Convert.String_to_Int_TwoType(List_Stair_Emergency[Temp_Index_Stair].ToString()) +
                                            _Convert.String_to_Int_TwoType(List_Floor_Emergency[Temp_Index_Floor].ToString());
                                    ///
                                    /// 이름
                                    ///

                                    Code_Position.Code_Position_NAME = Code_Position_Name_Create(BuildingName, StairName, FloorName);

                                    // 사용여부 해제
                                    Code_Position.Enable = false;

                                    // 해쉬 추가 
                                    // (디폴트로 생성되는 위치 코드 리스트이며 차후에 Import_Point 함수에서 실제로 사용되는 위치만 추출해서 변경된다
                                    // ID 를 참조하는게 아니라 이름을 기준으로 참조하므로 사용에 주의
                                    if (_Hash.Add(_Data.HASH_CodePosition, Code_Position.Code_Position_NAME, Code_Position) == true)
                                    {
                                        _Data.LIST_CodePosition_NAME.Add(Code_Position.Code_Position_NAME);
                                    }
                                }
                            }
                        }

                        //
                        // 입력코드 및 출력코드를 생성한결과에 데이타베이스의 TB_DEVICE_TYPE 에 저장하기 위한 필드들을 매칭시켜 저장해둔다
                        //

                        _Data.LIST_CodeDeviceType.Clear();

                        // 입력
                        foreach (string Input_TypeName in List_Input_TypeName)
                        {
                            _Code_Device_Type Table_Device_Type = new _Code_Device_Type();

                            // 데이타를 추출한다 (예시 : IA 일반화재입력)
                            string[] Temp_Input_TypeName = Input_TypeName.Split(' ');
                            if (Temp_Input_TypeName.Length != 2)
                            {
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError3, 0);
                                return false;
                            }

                            // 데이타 저장
                            Table_Device_Type.DEVICE_TYPE = Temp_Input_TypeName[0];
                            Table_Device_Type.DEVICE_TYPE_NAME = Temp_Input_TypeName[1];
                            Table_Device_Type.SYMBOL_TYPE = "I";
                            Table_Device_Type.SEQ_NO = "0";
                            Table_Device_Type.USE_FLAG = "Y";

                            // 클래스에 추가
                            _Data.LIST_CodeDeviceType.Add(Table_Device_Type);
                        }

                        // 출력
                        foreach (string Output_TypeName in List_Output_TypeName)
                        {
                            _Code_Device_Type Table_Device_Type = new _Code_Device_Type();

                            // 데이타를 추출한다 (예시 : OA 주경종)
                            string[] Temp_Output_TypeName = Output_TypeName.Split(' ');
                            if (Temp_Output_TypeName.Length != 2)
                            {
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError3, 0);
                                return false;
                            }

                            // 데이타 저장
                            Table_Device_Type.DEVICE_TYPE = Temp_Output_TypeName[0];
                            Table_Device_Type.DEVICE_TYPE_NAME = Temp_Output_TypeName[1];
                            Table_Device_Type.SYMBOL_TYPE = "O";
                            Table_Device_Type.SEQ_NO = List_Output_SEQ[List_Output_TypeName.IndexOf(Output_TypeName)].ToString();
                            Table_Device_Type.USE_FLAG = List_Output_USE[List_Output_TypeName.IndexOf(Output_TypeName)].ToString(); ;

                            // 클래스에 추가
                            _Data.LIST_CodeDeviceType.Add(Table_Device_Type);
                        }

                        //
                        // IO보드를 생성한결과에 데이타베이스의 TB_DEVICE 에 저장하기 위한 필드들을 매칭시켜 저장해둔다
                        //

                        // 중복된 내용이 있다면 사용불가
                        ArrayList Temp_IOBoard_Name = new ArrayList();
                        foreach (string Name in List_IOBoard_Name)
                        {
                            if (Temp_IOBoard_Name.Contains(Name) == false)
                                Temp_IOBoard_Name.Add(Name);
                        }
                        if (Temp_IOBoard_Name.Count != List_IOBoard_Name.Count)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError10, 0);
                            return false;
                        }

                        _Data.LIST_CodeIOBoard.Clear();

                        // IO
                        foreach (string IOBoard_Name in List_IOBoard_Name)
                        {
                            _Code_IO_Board IO_Board = new _Code_IO_Board();

                            // 데이타 저장
                            IO_Board.IOBOARD_NAME = IOBoard_Name;
                            IO_Board.IOBOARD_COM_PORT = List_IOBoard_ComPort[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_BOARD_ID = List_IOBoard_BoardID[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_LOOP_NO = List_IOBoard_LoopNo[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_REPEATER_ID = List_IOBoard_RepeaterID[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_DEVICE_ID = List_IOBoard_DeviceID[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_INOUT = List_IOBoard_InOut[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_ADDREPEATER_YN = List_IOBoard_AddRepeaterYesNo[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();
                            IO_Board.IOBOARD_ADDREPEATER_TYPE = List_IOBoard_AddRepeaterType[List_IOBoard_Name.IndexOf(IOBoard_Name)].ToString();

                            // 클래스에 추가
                            _Data.LIST_CodeIOBoard.Add(IO_Board);
                        }

                        //
                        // 이벤트타입 생성한결과에 데이타베이스의 TB_EVENT_TYPE 에 저장하기 위한 필드들을 매칭시켜 저장해둔다
                        //

                        _Data.LIST_CodeEventType.Clear();

                        // 이벤트 타입
                        foreach (string EventType in List_EventType_Type)
                        {
                            _Code_Event_Type Event_Type = new _Code_Event_Type();

                            // 데이타 저장
                            Event_Type.EVENT_TYPE = EventType;
                            Event_Type.EVENT_TYPE_NAME = List_EventType_Name[List_EventType_Type.IndexOf(EventType)].ToString();

                            // 클래스에 추가
                            _Data.LIST_CodeEventType.Add(Event_Type);
                        }

                        //
                        // 아날로그 감지 레벨 및 시간
                        //


                        // 0 : falut, 1 : PreFire, 2 : FireDay, 3 : FireNight

                        // cyim 2016.07.27 : 아날로그 감지기 레벨 감지기 타입별 설정 기능
                        _Data.LIST_CodeAnalogLevel_Smoke.Clear();
                        if (List_Analog_Level_Smoke.Count == 4)
                            _Data.LIST_CodeAnalogLevel_Smoke = (ArrayList)List_Analog_Level_Smoke.Clone();
                        else if (List_Analog_Level_Smoke.Count != 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError11, 0);
                            return false;
                        }

                        _Data.LIST_CodeAnalogLevel_Heat.Clear();
                        if (List_Analog_Level_Heat.Count == 4)
                            _Data.LIST_CodeAnalogLevel_Heat = (ArrayList)List_Analog_Level_Heat.Clone();
                        else if (List_Analog_Level_Heat.Count != 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError11, 0);
                            return false;
                        }

                        _Data.LIST_CodeFireDayTime.Clear();
                        if (List_FireDay_Time.Count == 4)
                        {
                            int start_Hour = _Convert.Null_to_IntZero(List_FireDay_Time[0]);
                            int start_Minute = _Convert.Null_to_IntZero(List_FireDay_Time[1]);
                            int end_Hour = _Convert.Null_to_IntZero(List_FireDay_Time[2]);
                            int end_Minute = _Convert.Null_to_IntZero(List_FireDay_Time[3]);

                            if ((start_Hour > end_Hour) || (start_Hour == end_Hour && start_Minute > end_Minute))
                            {
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError11, 0);
                                return false;
                            }
                            _Data.LIST_CodeFireDayTime = (ArrayList)List_FireDay_Time.Clone();
                        }
                        else if (List_FireDay_Time.Count != 0)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 550, 150, _Text.CodeError11, 0);
                            return false;
                        }
                        return true;
                    }
                }
                return false;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        // 사용하지 않음
        public static bool Import_Point_GetGroup(DataTable Sheets, OleDbConnection Connection)
        {
            try
            {
                // 코드 시트명을 가져온다                 
                for (int i = 0; i < Sheets.Rows.Count; i++)
                {
                    // 만약 가져오지 못한다면 실패로 처리함, 코드 시트명은 고정되어 있다! => 연동그룹$ 
                    if (Sheets.Rows[i]["TABLE_NAME"].ToString() == "연동그룹$")
                    {
                        // 시트명
                        string sheetname = Sheets.Rows[i]["TABLE_NAME"].ToString();

                        OleDbCommand Command = new OleDbCommand("Select * From [연동그룹$]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// 코드값들을 읽는다
                        ///

                        // 그룹아이디
                        ArrayList List_GroupID = new ArrayList();
                        // 그룹명
                        ArrayList List_GroupName = new ArrayList();

                        // 총개수
                        int AllCnt = Int32.Parse(Read_Data(ds, 1, 0));
                        // 그룹아이디 읽기
                        List_GroupID = Get_CodeData_Until_AllCnt(ds, 3, 0, AllCnt);
                        // 그룹명 읽기
                        List_GroupName = Get_CodeData_Until_AllCnt(ds, 3, 1, AllCnt);

                        // 단, 총개수와 입력한 데이타 개수가 동일하지 않으면 잘못된 데이타
                        if (AllCnt != List_GroupID.Count || AllCnt != List_GroupName.Count)
                            return false;

                        ///
                        /// 데이타베이스 연동을 위한 클래스를 생성한다
                        ///

                        _Data.List_ExcelGroup.Clear();

                        // 그룹정보를 생성한다 
                        for (int j = 0; j < AllCnt; j++)
                        {
                            _Excel_Group Excel_Group = new _Excel_Group();
                            Excel_Group.Group_ID = List_GroupID[j].ToString();
                            Excel_Group.Group_Name = List_GroupName[j].ToString();

                            _Data.List_ExcelGroup.Add(Excel_Group);
                        }
                        return true;
                    }
                }
                // _Data.List_ExcelGroup.Count 가 0 도 허용한다
                return true;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        // 사용하지 않음
        public static bool Import_Point_GetMap(DataTable Sheets, OleDbConnection Connection)
        {
            try
            {
                // 코드 시트명을 가져온다                 
                for (int i = 0; i < Sheets.Rows.Count; i++)
                {
                    // 만약 가져오지 못한다면 실패로 처리함, 코드 시트명은 고정되어 있다! => 연동그룹$ 
                    if (Sheets.Rows[i]["TABLE_NAME"].ToString() == "연동설정$")
                    {
                        // 시트명
                        string sheetname = Sheets.Rows[i]["TABLE_NAME"].ToString();

                        OleDbCommand Command = new OleDbCommand("Select * From [연동설정$]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// 코드값들을 읽는다
                        ///

                        // 그룹아이디
                        ArrayList List_MapID = new ArrayList();
                        // 그룹명
                        ArrayList List_MapName = new ArrayList();

                        // 총개수
                        int AllCnt = Int32.Parse(Read_Data(ds, 1, 0));
                        // 그룹아이디 읽기
                        List_MapID = Get_CodeData_Until_AllCnt(ds, 3, 0, AllCnt);
                        // 그룹명 읽기
                        List_MapName = Get_CodeData_Until_AllCnt(ds, 3, 1, AllCnt);

                        // 단, 총개수와 입력한 데이타 개수가 동일하지 않으면 잘못된 데이타
                        if (AllCnt != List_MapID.Count || AllCnt != List_MapName.Count)
                            return false;

                        ///
                        /// 데이타베이스 연동을 위한 클래스를 생성한다
                        ///

                        _Data.List_ExcelMap.Clear();

                        // 그룹정보를 생성한다 
                        for (int j = 0; j < AllCnt; j++)
                        {
                            _Excel_Map Excel_Map = new _Excel_Map();
                            Excel_Map.Map_ID = List_MapID[j].ToString();
                            Excel_Map.Map_Name = List_MapName[j].ToString();

                            _Data.List_ExcelMap.Add(Excel_Map);
                        }
                        return true;
                    }
                }
                // _Data.List_ExcelMap.Count 가 0 도 허용한다
                return true;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        public static string Read_Data(DataSet ds, int row, int col)
        {
            // 디버깅으로 사용되는 데이타
            Debug_Row = row + 1;
            Debug_Col = col + 1;

            // 반환값
            return ds.Tables[0].Rows[row][col].ToString();
        }

        // 그룹 엑셀 임포트
        public static bool Import_Group(string FileFullPath)
        {
            string CheckConnectionString = ConnectionString(FileFullPath);
            if (CheckConnectionString == null)
            {
                // 파일 확장자를 확인해주세요
                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.CheckFileFormatInform, 0);
                return false;
            }

            // 엑셀 문서 접근
            OleDbConnection Connection = new OleDbConnection(CheckConnectionString);

            try
            {
                // 엑셀 문서 읽기
                Connection.Open();

                // 시트명을 가져온다
                DataTable worksheets = Connection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);

                // 코드 시트명을 가져온다                 
                for (int i = 0; i < worksheets.Rows.Count; i++)
                {
                    // 만약 가져오지 못한다면 실패로 처리함, 코드 시트명은 고정되어 있다! => 연동그룹$ 
                    if (worksheets.Rows[i]["TABLE_NAME"].ToString() == "연동그룹$")
                    {
                        // 시트명
                        string sheetname = worksheets.Rows[i]["TABLE_NAME"].ToString();

                        OleDbCommand Command = new OleDbCommand("Select * From [연동그룹$]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// 코드값들을 읽는다
                        ///

                        // 그룹아이디
                        ArrayList List_GroupID = new ArrayList();
                        // 그룹명
                        ArrayList List_GroupName = new ArrayList();

                        // 총개수가 '' 또는 ' ' 는 에러 메시지 출력
                        if (Read_Data(ds, 1, 0).Trim() == _Text.Null)
                        {
                            string Error = " [시트명]: 연동그룹" + " [행]:2  [열]:1";

                            // 파일 포맷이 잘못되었습니다
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                            // LOG
                            _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                            // 엑셀 읽기 세션 해제
                            if (Connection != null) Connection.Close();

                            return false;
                        }

                        // 총개수
                        int AllCnt = Int32.Parse(Read_Data(ds, 1, 0));

                        // 먼저 아이디, 맵리스트, 연동그룹수 값이 '' 또는 ' ' 는 에러 메시지 출력
                        for (int x = 0; x < 2; x++)
                        {
                            for (int y = 0; y < AllCnt; y++)
                            {
                                string Value = Read_Data(ds, y + 3, x);

                                // 값이 '' 또는 ' ' 는 에러 메시지 출력
                                if (Value.Trim() == _Text.Null)
                                {
                                    // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                    string Error = " [시트명]: 연동그룹" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                    // 파일 포맷이 잘못되었습니다
                                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                    // LOG
                                    _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                    // 엑셀 읽기 세션 해제
                                    if (Connection != null) Connection.Close();

                                    return false;
                                }
                                else
                                {
                                    if (x == 0)
                                    {
                                        if (_Data.Project_MapGroupIDTypeNumber == "6" && Value.Length != 7) // 6자리모드 인 경우에는 7자리이다 
                                        {
                                            // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                            string Error = " [시트명]: 연동그룹" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                            // 파일 포맷이 잘못되었습니다
                                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 600, 150, _Text.DigitNumberExcel_6 + Error, 0);

                                            // LOG
                                            _Event.DebugView_SendMessage_Write(_Text.DigitNumberExcel_6 + Error + " 의 정보를 확인해주세요 ");

                                            // 엑셀 읽기 세션 해제
                                            if (Connection != null) Connection.Close();

                                            return false;
                                        }
                                        if (_Data.Project_MapGroupIDTypeNumber == "4" && Value.Length != 5) // 4자리모드 인 경우에는 5자리이다
                                        {
                                            // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                            string Error = " [시트명]: 연동그룹" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                            // 파일 포맷이 잘못되었습니다
                                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 600, 150, _Text.DigitNumberExcel_4 + Error, 0);

                                            // LOG
                                            _Event.DebugView_SendMessage_Write(_Text.DigitNumberExcel_4 + Error + " 의 정보를 확인해주세요 ");

                                            // 엑셀 읽기 세션 해제
                                            if (Connection != null) Connection.Close();

                                            return false;
                                        }
                                    }
                                }
                            }
                        }

                        // 그룹아이디가 엑셀 정보 안에서 동일한게 있는지 확인
                        ArrayList Group_List = new ArrayList();

                        for (int y = 0; y < AllCnt; y++)
                        {
                            string Value = Read_Data(ds, y + 3, 0);

                            if (Group_List.Contains(Value.Trim()) == false) // 없다
                            {
                                Group_List.Add(Value.Trim());
                            }
                            else // 있다
                            {
                                // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                string Error = " [시트명]: 연동그룹" + " [행]:" + (y + 3 + 1) + " [열]:" + (0 + 1);

                                // 파일 포맷이 잘못되었습니다
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                // LOG
                                _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                // 엑셀 읽기 세션 해제
                                if (Connection != null) Connection.Close();

                                return false;
                            }
                        }

                        // 그룹아이디 읽기
                        List_GroupID = Get_CodeData_Until_AllCnt(ds, 3, 0, AllCnt);
                        // 그룹명 읽기
                        List_GroupName = Get_CodeData_Until_AllCnt(ds, 3, 1, AllCnt);

                        //// 단, 총개수와 입력한 데이타 개수가 동일하지 않으면 잘못된 데이타
                        //if (AllCnt != List_GroupID.Count || AllCnt != List_GroupName.Count)
                        //    return false;

                        ///
                        /// 데이타베이스 연동을 위한 클래스를 생성한다
                        ///

                        _Data.List_ExcelGroup.Clear();

                        // 그룹정보를 생성한다 
                        for (int j = 0; j < AllCnt; j++)
                        {
                            _Excel_Group Excel_Group = new _Excel_Group();
                            Excel_Group.Group_ID = List_GroupID[j].ToString();
                            Excel_Group.Group_Name = List_GroupName[j].ToString();

                            _Data.List_ExcelGroup.Add(Excel_Group);
                        }
                        return true;
                    }
                }

                // 엑셀 읽기 세션 해제
                if (Connection != null) Connection.Close();
                // _Data.List_ExcelGroup.Count 가 0 도 허용한다
                return true;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        // 맵 연동 엑셀 임포트
        public static bool Import_Map(string FileFullPath, string ReceiverID)
        {
            string CheckConnectionString = ConnectionString(FileFullPath);
            if (CheckConnectionString == null)
            {
                // 파일 확장자를 확인해주세요
                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.CheckFileFormatInform, 0);
                return false;
            }

            // 엑셀 문서 접근
            OleDbConnection Connection = new OleDbConnection(CheckConnectionString);

            try
            {
                // 엑셀 문서 읽기
                Connection.Open();

                // 시트명을 가져온다
                DataTable worksheets = Connection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);

                // 코드 시트명을 가져온다                 
                for (int i = 0; i < worksheets.Rows.Count; i++)
                {
                    // 만약 가져오지 못한다면 실패로 처리함, 코드 시트명은 고정되어 있다! => 연동그룹$ 
                    if (worksheets.Rows[i]["TABLE_NAME"].ToString() == "연동설정$")
                    {
                        // 시트명
                        string sheetname = worksheets.Rows[i]["TABLE_NAME"].ToString();

                        OleDbCommand Command = new OleDbCommand("Select * From [연동설정$]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// 코드값들을 읽는다
                        ///

                        // 그룹아이디
                        ArrayList List_MapID = new ArrayList();
                        // 그룹명
                        ArrayList List_MapName = new ArrayList();
                        // 연동 그룹수
                        ArrayList List_GroupNumber = new ArrayList();
                        // 추가된 그룹들
                        ArrayList List_Groups = new ArrayList();
                        // 입력 개수
                        ArrayList List_InDeviceNumber = new ArrayList();
                        // 입력 디바이스들
                        ArrayList List_InDevice = new ArrayList();

                        // 총개수가 '' 또는 ' ' 는 에러 메시지 출력
                        if (Read_Data(ds, 1, 0).Trim() == _Text.Null)
                        {
                            // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                            string Error = " [시트명]: 연동그룹" + " [행]:2  [열]:1";

                            // 파일 포맷이 잘못되었습니다
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                            // LOG
                            _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                            // 엑셀 읽기 세션 해제
                            if (Connection != null) Connection.Close();
                            return false;
                        }

                        // 총개수
                        int AllCnt = Int32.Parse(Read_Data(ds, 1, 0));

                        // 입력개수가 '' 또는 ' ' 는 에러 메시지 출력
                        for (int y = 0; y < AllCnt; y++)
                        {
                            string Value = Read_Data(ds, y + 3, 13);

                            // 값이 '' 또는 ' ' 는 에러 메시지 출력
                            if (Value.Trim() == _Text.Null)
                            {
                                // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (13 + 1);

                                // 파일 포맷이 잘못되었습니다
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                // LOG
                                _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                // 엑셀 읽기 세션 해제
                                if (Connection != null) Connection.Close();

                                return false;
                            }
                        }

                        // 아이디, 맵리스트, 연동그룹수 값이 '' 또는 ' ' 는 에러 메시지 출력
                        for (int x = 0; x < 3; x++)
                        {
                            for (int y = 0; y < AllCnt; y++)
                            {
                                string Value = Read_Data(ds, y + 3, x);

                                // 값이 '' 또는 ' ' 는 에러 메시지 출력
                                if (Value.Trim() == _Text.Null)
                                {
                                    // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                    string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                    // 파일 포맷이 잘못되었습니다
                                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                    // LOG
                                    _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                    // 엑셀 읽기 세션 해제
                                    if (Connection != null) Connection.Close();

                                    return false;
                                }
                                else
                                {
                                    if (x == 0)
                                    {
                                        if (_Data.Project_MapGroupIDTypeNumber == "6" && Value.Length != 7) // 6자리모드 인 경우에는 7자리이다 
                                        {
                                            // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                            string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                            // 파일 포맷이 잘못되었습니다
                                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 600, 150, _Text.DigitNumberExcel_6 + Error, 0);

                                            // LOG
                                            _Event.DebugView_SendMessage_Write(_Text.DigitNumberExcel_6 + Error + " 의 정보를 확인해주세요 ");

                                            // 엑셀 읽기 세션 해제
                                            if (Connection != null) Connection.Close();

                                            return false;
                                        }
                                        if (_Data.Project_MapGroupIDTypeNumber == "4" && Value.Length != 5) // 4자리모드 인 경우에는 5자리이다
                                        {
                                            // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                            string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (x + 1);

                                            // 파일 포맷이 잘못되었습니다
                                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 600, 150, _Text.DigitNumberExcel_4 + Error, 0);

                                            // LOG
                                            _Event.DebugView_SendMessage_Write(_Text.DigitNumberExcel_4 + Error + " 의 정보를 확인해주세요 ");

                                            // 엑셀 읽기 세션 해제
                                            if (Connection != null) Connection.Close();

                                            return false;
                                        }
                                    }
                                }
                            }
                        }

                        // 맵아이디가 엑셀 정보 안에서 동일한게 있는지 확인
                        ArrayList Map_List = new ArrayList();

                        for (int y = 0; y < AllCnt; y++)
                        {
                            string Value = Read_Data(ds, y + 3, 0);

                            if (Map_List.Contains(Value.Trim()) == false) // 없다
                            {
                                Map_List.Add(Value.Trim());
                            }
                            else // 있다
                            {
                                // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (0 + 1);

                                // 파일 포맷이 잘못되었습니다
                                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                // LOG
                                _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                // 엑셀 읽기 세션 해제
                                if (Connection != null) Connection.Close();
                                return false;
                            }
                        }

                        // 맵아이디가 DB에 동일한게 있는지 확인
                        for (int y = 0; y < AllCnt; y++)
                        {
                            string Value = Read_Data(ds, y + 3, 0);

                            //** TB_MAP 테이블에서 맵명을 모두 가지고 온다
                            DataRowCollection DB_TABLE_MAP = _Db.ExecuteRead_SqlDataAdapter(_Sql.SearchAll_Table_Value("TB_MAP", "MAP_ID", Value.Trim(), null));

                            if (DB_TABLE_MAP != null)
                            {
                                foreach (DataRow dr in DB_TABLE_MAP)
                                {
                                    if (DB_TABLE_MAP.Count != 0) // 없다
                                    {
                                        // 1을 플러스 한 이유는 엑셀의 에러 지점을 정확히 나타내기 위해
                                        string Error = " [시트명]: 연동설정" + " [행]:" + (y + 3 + 1) + " [열]:" + (0 + 1);

                                        // 파일 포맷이 잘못되었습니다
                                        _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 500, 150, _Text.FailDataInform + Error + " 정보가 이미 DB에 있습니다 ", 0);

                                        // LOG
                                        _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 정보가 이미 DB에 있습니다 ");

                                        // 엑셀 읽기 세션 해제
                                        if (Connection != null) Connection.Close();
                                        return false;
                                    }
                                }
                            }
                        }

                        // 그룹아이디 읽기
                        List_MapID = Get_CodeData_Until_AllCnt(ds, 3, 0, AllCnt);

                        // 그룹명 읽기
                        List_MapName = Get_CodeData_Until_AllCnt(ds, 3, 1, AllCnt);

                        // 연동 그룹수 읽기
                        List_GroupNumber = Get_CodeData_Until_AllCnt(ds, 3, 2, AllCnt);

                        // 입력 개수
                        List_InDeviceNumber = Get_CodeData_Until_AllCnt(ds, 3, 13, AllCnt);

                        // 행을 하나씩 올려준다
                        int PlusCount = 0;

                        // 그룹 읽기
                        foreach (string num in List_GroupNumber)
                        {
                            string data = _Text.Null;

                            for (int x = 0; x < Int32.Parse(num); x++)
                            {
                                string Value = Read_Data(ds, PlusCount + 3, x + 3);

                                // 값이 '' 또는 ' ' 는 에러 메시지 출력
                                if (Value.Trim() == _Text.Null)
                                {
                                    string Error = " [시트명]: 연동설정" + " [행]:" + (PlusCount + 3 + 1) + " [열]:" + (x + 3 + 1);

                                    // 파일 포맷이 잘못되었습니다
                                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                    // LOG
                                    _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                    // 엑셀 읽기 세션 해제
                                    if (Connection != null) Connection.Close();

                                    return false;
                                }

                                // :G0001:G0002:G0003:G0004 이런씩으로 저장
                                data = data + ":" + Value.Trim();
                            }
                            if (data == _Text.Null) List_Groups.Add(_Text.Null); // 그룹을 추가하지 않은것
                            else List_Groups.Add(data.Remove(0, 1)); // 그룹이 하나라도 있으면 맨 앞에 ":" 제거

                            // 다음 행에서 작업
                            PlusCount++;
                        }

                        // 행을 하나씩 올려준다
                        int Count = 0;
                        // 입력 읽기
                        foreach (string num in List_InDeviceNumber)
                        {
                            string data = _Text.Null;

                            for (int x = 0; x < Int32.Parse(num); x++)
                            {
                                string Value = Read_Data(ds, Count + 3, x + 14);

                                // 값이 '' 또는 ' ' 는 에러 메시지 출력
                                if (Value.Trim() == _Text.Null)
                                {
                                    string Error = " [시트명]: 연동설정" + " [행]:" + (Count + 3 + 1) + " [열]:" + (x + 14 + 1);

                                    // 파일 포맷이 잘못되었습니다
                                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 350, 150, _Text.FailDataInform + Error, 0);

                                    // LOG
                                    _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                    // 엑셀 읽기 세션 해제
                                    if (Connection != null) Connection.Close();
                                    return false;
                                }

                                // 해당 입력 디바이스가 존재하는 검사

                                // BOARD_ID, LOOP_NO, REPEATER_ID, DEVICE_ID

                                string[] temp = Value.Trim().Split('-');
                                DataRowCollection DB_TABLE_DEVICE = _Db.ExecuteRead_SqlDataAdapter(
                                    _Sql.SearchAll_Table_Value("TB_DEVICE", "COMM_ID", "1", "INOUT_TYPE", "I", "BOARD_ID", temp[1], "LOOP_NO", temp[2], "REPEATER_ID", temp[3], "DEVICE_ID", temp[4], ReceiverID));

                                if (DB_TABLE_DEVICE != null)
                                {
                                    if (DB_TABLE_DEVICE.Count == 0)
                                    {
                                        string Error = " [시트명]: 연동설정" + " [행]:" + (Count + 3 + 1) + " [열]:" + (x + 14 + 1);

                                        // 파일 포맷이 잘못되었습니다
                                        _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 500, 150, "[" + Value.Trim() + "]" + _Text.FailDevice + Error, 0);

                                        // LOG
                                        _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 ");

                                        // 엑셀 읽기 세션 해제
                                        if (Connection != null) Connection.Close();

                                        return false;
                                    }
                                }
                                // 포맷이 변경되지 않는다. 어차피 각각 수신기에 대하여 엑셀은 따로 존재하고 각각 Import 수행하면 반드시 그 회로는 관할 수신기의 입력회로이다
                                // :MI-01-1-001-1:MI-01-1-001-2:MI-01-1-001-2 이런씩으로 저장 ->
                                data = data + ":" + Value.Trim();
                            }

                            if (data == _Text.Null) List_InDevice.Add(_Text.Null); // 입력디바이스 추가하지 않은것
                            else List_InDevice.Add(data.Remove(0, 1)); // 입력디바이스가 하나라도 있으면 맨 앞에 ":" 제거

                            // 다음 행에서 작업
                            Count++;
                        }

                        // 단, 총개수와 입력한 데이타 개수가 동일하지 않으면 잘못된 데이타
                        //if (AllCnt != List_MapID.Count || AllCnt != List_MapName.Count)
                        //    return false;

                        ///
                        /// 데이타베이스 연동을 위한 클래스를 생성한다
                        ///

                        _Data.List_ExcelMap.Clear();

                        // 그룹정보를 생성한다 
                        for (int j = 0; j < AllCnt; j++)
                        {
                            _Excel_Map Excel_Map = new _Excel_Map();
                            Excel_Map.Map_ID = List_MapID[j].ToString();
                            Excel_Map.Map_Name = List_MapName[j].ToString();
                            Excel_Map.Group_Number = List_GroupNumber[j].ToString();
                            Excel_Map.Groups = List_Groups[j].ToString();
                            Excel_Map.InDevices = List_InDevice[j].ToString();

                            _Data.List_ExcelMap.Add(Excel_Map);
                        }
                        return true;
                    }
                }

                // 엑셀 읽기 세션 해제
                if (Connection != null) Connection.Close();
                // _Data.List_ExcelGroup.Count 가 0 도 허용한다
                return true;
            }
            catch (Exception e)
            {
                _Event.DebugView_SendMessage_Write(e.ToString());
                return false;
            }
        }

        // Import  
        public static bool Import_Point(string FileFullPath)
        {
            int RepeaterRowNum = 0;

            // 디버깅 변수 초기화
            Debug_Row = 0;
            Debug_Col = 0;
            Debug_SheetName = null;
            Debug_EtcMessage = null;

            string CheckConnectionString = ConnectionString(FileFullPath);
            if (CheckConnectionString == null)
            {
                // 파일 확장자를 확인해주세요
                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.CheckFileFormatInform, 0);
                return false;
            }

            // 엑셀 문서 접근
            OleDbConnection Connection = new OleDbConnection(CheckConnectionString);

            try
            {
                // 엑셀 문서 읽기
                Connection.Open();

                // 시트명을 가져온다
                DataTable worksheets = Connection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);

                ///
                /// 1. 코드값 저장
                /// 
                /// 코드 시트가 있는지 확인하고 없다면 루틴을 돌지 않도록 한다
                /// 또한 _Data.Class_ExcelCode 에 코드 정보를 저장하여 차후에 사용하도록 클래스를 저장한다
                ///

                if (Import_Point_GetCode(worksheets, Connection) == false)
                {
                    // 코드 시트가 잘못되었습니다
                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.FailCodeInform, 0);
                    return false;
                }

                /// 
                /// 2. 포인트 정보 저장
                /// 
                /// 포인트 정보를 저장하는 리스트이다 (가장 중요한 리스트이다, 시트별-중계기별-입출력포인트 순으로 클래스화 하여 저장한다)
                /// 

                // 초기화
                _Data.List_ExcelPoint.Clear();

                // 엑셀 시트 수에 맞게 데이타를 읽어 온다
                for (int i = 0; i < worksheets.Rows.Count; i++)
                {
                    // 시트명
                    string sheetname = worksheets.Rows[i]["TABLE_NAME"].ToString();

                    // 읽지 않는 시트인지 판별
                    if (Import_Point_CheckSheetName(sheetname) == true)
                    {
                        // Debug
                        Debug_SheetName = sheetname.Replace("$", "");

                        // 읽은 정보를 데이타셋에 매칭
                        OleDbCommand Command = new OleDbCommand("Select * From [" + sheetname + "]", Connection);
                        OleDbDataAdapter dapt = new OleDbDataAdapter(Command);
                        DataSet ds = new DataSet();
                        dapt.Fill(ds);

                        ///
                        /// _Excel_Sheet 클래스 생성
                        ///
                        _Excel_Sheet Excel_Sheet = new _Excel_Sheet();

                        // 시트명
                        Excel_Sheet.Sheet_Name = sheetname;
                        // 통신 보드 
                        Excel_Sheet.BOARD_ID = Read_Data(ds, 1, 0);
                        if (Excel_Sheet.BOARD_ID == null || Excel_Sheet.BOARD_ID.Trim().Length == 0 || Int32.Parse(Excel_Sheet.BOARD_ID) <= 0 || Int32.Parse(Excel_Sheet.BOARD_ID) > 68)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 450, 150, _Text.ExceptionError2, 0);
                            return false;
                        }

                        // 계통                        
                        Excel_Sheet.LOOP_NO = Read_Data(ds, 1, 1);
                        if (Excel_Sheet.LOOP_NO == null || Excel_Sheet.LOOP_NO.Trim().Length == 0 || Int32.Parse(Excel_Sheet.LOOP_NO) <= 0 || Int32.Parse(Excel_Sheet.LOOP_NO) > 4)
                        {
                            _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 450, 150, _Text.ExceptionError3, 0);
                            return false;
                        }

                        // 중계기 총개수
                        Excel_Sheet.Repeater_Count = Int32.Parse(Read_Data(ds, 1, 2));

                        // 시트안에 중계기 개수 만큼 루프 생성
                        for (int j = 0; j < Excel_Sheet.Repeater_Count; j++)
                        {
                            ///
                            /// _Excel_Repeater 클래스 생성
                            ///

                            _Excel_Repeater Excel_Repeater = new _Excel_Repeater();

                            // 중계기 타입
                            string Temp_Repeater_Type = Read_Data(ds, 4 + (j * 5), 1);
                            if (Temp_Repeater_Type == null || Temp_Repeater_Type.Trim().Length == 0)
                            {
                                Debug_Row = 4 + (j * 5) + 1;
                                Debug_Col = 1 + 1;
                                throw new Exception();
                            }
                            else if (Temp_Repeater_Type == "None")
                            {
                                ;// 사용하지 않는 중계기는 무시한다
                            }
                            else
                            {
                                // 중계기 검사 타입
                                if (Read_Data(ds, 4 + (j * 5), 1) == "4*4")
                                    Excel_Repeater.TYPE = POINT_TYPE.REPEATER_4_4;
                                else if (Read_Data(ds, 4 + (j * 5), 1) == "2*2")
                                    Excel_Repeater.TYPE = POINT_TYPE.REPEATER_2_2;
                                else if (Read_Data(ds, 4 + (j * 5), 1) == "연감지기")
                                    Excel_Repeater.TYPE = POINT_TYPE.ANALOG_SMOKE;
                                else if (Read_Data(ds, 4 + (j * 5), 1) == "열감지기")
                                    Excel_Repeater.TYPE = POINT_TYPE.ANALOG_HEAT;
                                else
                                // 중계기 타입이 없다면 예외                                
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 1;
                                    throw new Exception();
                                }

                                // 필요 이상 회로 정보가 있다면 예외                                
                                int Temp_RepeaterRowNum = 0;
                                string Temp_Info = null;
                                int Temp_Info_Cnt = 0;
                                if (Excel_Repeater.TYPE == POINT_TYPE.REPEATER_2_2
                                    || Excel_Repeater.TYPE == POINT_TYPE.ANALOG_SMOKE
                                    || Excel_Repeater.TYPE == POINT_TYPE.ANALOG_HEAT)
                                {
                                    for (int k = 1; k <= 4; k++)
                                    {
                                        // 중계기 행번호
                                        Temp_RepeaterRowNum = 4 + (j * 5);
                                        // 위치정보
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 2);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 3);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 4);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 5);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 6);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 7);
                                        Temp_Info += Read_Data(ds, Temp_RepeaterRowNum + k, 8);

                                        // 내용이 있다면
                                        if (Temp_Info != null && Temp_Info.Length != 0)
                                            Temp_Info_Cnt++;
                                        // 초기화
                                        Temp_Info = null;
                                    }
                                    if (Excel_Repeater.TYPE == POINT_TYPE.REPEATER_2_2)
                                    {
                                        // 중계기 회로가 2*2 인데 더 많은 정보가 있으므로 틀리다
                                        if (Temp_Info_Cnt > 2)
                                        {
                                            Debug_Row = 4 + (j * 5) + 1;
                                            Debug_Col = 1;
                                            throw new Exception();
                                        }
                                    }
                                    else if (Excel_Repeater.TYPE == POINT_TYPE.ANALOG_SMOKE || Excel_Repeater.TYPE == POINT_TYPE.ANALOG_HEAT)
                                    {
                                        // 연감지기 및 열감지기는 더 많은 정보가 있으므로 틀리다
                                        if (Temp_Info_Cnt > 1)
                                        {
                                            Debug_Row = 4 + (j * 5) + 1;
                                            Debug_Col = 1;
                                            throw new Exception();
                                        }
                                    }
                                }

                                // 중계기 아이디
                                Excel_Repeater.REPEATER_ID = Read_Data(ds, 4 + (j * 5), 0);

                                // 중계기 아이디가 없다면 예외
                                if (Excel_Repeater.REPEATER_ID == null || Excel_Repeater.REPEATER_ID.Trim().Length == 0)
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 0;
                                    throw new Exception();
                                }

                                // 중계기 위치 정보
                                Excel_Repeater.Excel_Position.Building = Read_Data(ds, 4 + (j * 5), 2);
                                Excel_Repeater.Excel_Position.Stair = Read_Data(ds, 4 + (j * 5), 3);
                                Excel_Repeater.Excel_Position.Floor = Read_Data(ds, 4 + (j * 5), 4);

                                // 중계기 위치 정보 없다면 예외
                                if (Excel_Repeater.Excel_Position.Building == null || Excel_Repeater.Excel_Position.Building.Trim().Length == 0)
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 2;
                                    throw new Exception();
                                }
                                if (Excel_Repeater.Excel_Position.Stair == null || Excel_Repeater.Excel_Position.Stair.Trim().Length == 0)
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 3;
                                    throw new Exception();
                                }
                                if (Excel_Repeater.Excel_Position.Floor == null || Excel_Repeater.Excel_Position.Floor.Trim().Length == 0)
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 4;
                                    throw new Exception();
                                }

                                // 위치 코드 사용여부 체크
                                string Temp_Repeater_Position_Name = Code_Position_Name_Create(
                                    Excel_Repeater.Excel_Position.Building, Excel_Repeater.Excel_Position.Stair, Excel_Repeater.Excel_Position.Floor);
                                // 위치 코드가 잘못되었다
                                if (Code_Position_Enable_Check(Temp_Repeater_Position_Name) == false)
                                {
                                    Debug_EtcMessage = _Text.FailDataInform_NotCodePostionName;
                                    throw new Exception();
                                }

                                // 중계기 명칭
                                Excel_Repeater.NAME = Read_Data(ds, 4 + (j * 5), 5);

                                // 중계기 명칭 없다면 예외
                                if (Excel_Repeater.NAME == null || Excel_Repeater.NAME.Trim().Length == 0)
                                {
                                    Debug_Row = 4 + (j * 5) + 1;
                                    Debug_Col = 5;
                                    throw new Exception();
                                }

                                // 중계기 타입에 상관없이 무조건 4행 단위로 읽는다
                                for (int k = 1; k <= 4; k++)
                                {
                                    // 중계기 행번호
                                    RepeaterRowNum = 4 + (j * 5);

                                    // 디바이스 아이디(중계기타입 아래칸)은 제대로된 순번을 넣어야한다
                                    if (Read_Data(ds, RepeaterRowNum + k, 1) != k.ToString())
                                    {
                                        Debug_Row = 4 + (j * 5) + k + 1;
                                        Debug_Col = 1;
                                        throw new Exception();
                                    }

                                    ///
                                    /// _Excel_Point 클래스 생성 (입력부)
                                    ///

                                    // 디바이스 명칭이 없다면 제외
                                    if (ds.Tables[0].Rows[RepeaterRowNum + k][5] != null && ds.Tables[0].Rows[RepeaterRowNum + k][5].ToString().Length != 0)
                                    {
                                        string TempDeviceName = Read_Data(ds, RepeaterRowNum + k, 5);
                                        TempDeviceName = TempDeviceName.Trim();

                                        if (TempDeviceName != null && TempDeviceName.Length != 0)
                                        {
                                            _Excel_Point Excel_Point_Input = new _Excel_Point();
                                            // 입력 포인트 타입
                                            Excel_Point_Input.TYPE = POINT_TYPE.I;
                                            // 입력 포인트 PortNum
                                            Excel_Point_Input.PortNum = ds.Tables[0].Rows[RepeaterRowNum + k][1].ToString();
                                            // 입력 포인트 위치 정보
                                            Excel_Point_Input.Excel_Position.Building = Read_Data(ds, RepeaterRowNum + k, 2);
                                            Excel_Point_Input.Excel_Position.Stair = Read_Data(ds, RepeaterRowNum + k, 3);
                                            Excel_Point_Input.Excel_Position.Floor = Read_Data(ds, RepeaterRowNum + k, 4);

                                            // 위치 코드 사용여부 체크
                                            string Temp_Point_Position_Name = Code_Position_Name_Create(
                                                Excel_Point_Input.Excel_Position.Building, Excel_Point_Input.Excel_Position.Stair, Excel_Point_Input.Excel_Position.Floor);
                                            if (Code_Position_Enable_Check(Temp_Point_Position_Name) == false)
                                            {
                                                Debug_EtcMessage = _Text.FailDataInform_NotCodePostionName;
                                                throw new Exception();
                                            }

                                            // 입력 포인트 명칭
                                            Excel_Point_Input.NAME = TempDeviceName;
                                            // 입력 포인트 코드
                                            Excel_Point_Input.Code_FullName = Read_Data(ds, RepeaterRowNum + k, 6);
                                            string[] TempCode = Excel_Point_Input.Code_FullName.Split(' ');
                                            Excel_Point_Input.Code_Type = TempCode[0];
                                            Excel_Point_Input.Code_Name = TempCode[1];

                                            // 리스트에 추가
                                            Excel_Repeater.List_Point.Add(Excel_Point_Input);
                                        }
                                    }
                                    // 단, 명칭은 없지만, 코드가 존재하는 경우는 예외다
                                    else
                                    {
                                        // 코드가 존재하는 경우
                                        if (ds.Tables[0].Rows[RepeaterRowNum + k][6] != null && ds.Tables[0].Rows[RepeaterRowNum + k][6].ToString().Trim().Length != 0)
                                        {
                                            // 명칭이 없는 경우만
                                            if (ds.Tables[0].Rows[RepeaterRowNum + k][5] == null || ds.Tables[0].Rows[RepeaterRowNum + k][5].ToString().Trim().Length == 0)
                                            {
                                                Debug_Row = RepeaterRowNum + k + 1;
                                                Debug_Col = 5 + 1;
                                                throw new Exception();
                                            }
                                        }
                                    }

                                    ///
                                    /// _Excel_Point 클래스 생성 (출력부)
                                    ///

                                    // 디바이스 명칭이 없다면 제외
                                    if (ds.Tables[0].Rows[RepeaterRowNum + k][7] != null && ds.Tables[0].Rows[RepeaterRowNum + k][7].ToString().Length != 0)
                                    {
                                        string TempDeviceName = Read_Data(ds, RepeaterRowNum + k, 7);
                                        TempDeviceName = TempDeviceName.Trim();

                                        if (TempDeviceName != null && TempDeviceName.Length != 0)
                                        {
                                            _Excel_Point Excel_Point_Output = new _Excel_Point();
                                            // 출력 포인트 타입
                                            Excel_Point_Output.TYPE = POINT_TYPE.O;
                                            // 출력 포인트 PortNum
                                            Excel_Point_Output.PortNum = ds.Tables[0].Rows[RepeaterRowNum + k][1].ToString();
                                            // 출력 포인트 위치 정보
                                            Excel_Point_Output.Excel_Position.Building = Read_Data(ds, RepeaterRowNum + k, 2);
                                            Excel_Point_Output.Excel_Position.Stair = Read_Data(ds, RepeaterRowNum + k, 3);
                                            Excel_Point_Output.Excel_Position.Floor = Read_Data(ds, RepeaterRowNum + k, 4);

                                            // 위치 코드 사용여부 체크
                                            string Temp_Point_Position_Name = Code_Position_Name_Create(
                                                Excel_Point_Output.Excel_Position.Building, Excel_Point_Output.Excel_Position.Stair, Excel_Point_Output.Excel_Position.Floor);
                                            if (Code_Position_Enable_Check(Temp_Point_Position_Name) == false)
                                            {
                                                Debug_EtcMessage = _Text.FailDataInform_NotCodePostionName;
                                                throw new Exception();
                                            }

                                            // 출력 포인트 명칭
                                            Excel_Point_Output.NAME = TempDeviceName;
                                            // 출력 포인트 코드
                                            Excel_Point_Output.Code_FullName = Read_Data(ds, RepeaterRowNum + k, 8);
                                            string[] TempCode = Excel_Point_Output.Code_FullName.Split(' ');
                                            Excel_Point_Output.Code_Type = TempCode[0];
                                            Excel_Point_Output.Code_Name = TempCode[1];

                                            // 리스트에 추가
                                            Excel_Repeater.List_Point.Add(Excel_Point_Output);
                                        }
                                    }
                                    // 단, 명칭은 없지만, 코드가 존재하는 경우는 예외다
                                    else
                                    {
                                        // 코드가 존재하는 경우
                                        if (ds.Tables[0].Rows[RepeaterRowNum + k][8] != null && ds.Tables[0].Rows[RepeaterRowNum + k][8].ToString().Trim().Length != 0)
                                        {
                                            // 명칭이 없는 경우만
                                            if (ds.Tables[0].Rows[RepeaterRowNum + k][7] == null || ds.Tables[0].Rows[RepeaterRowNum + k][7].ToString().Trim().Length == 0)
                                            {
                                                Debug_Row = RepeaterRowNum + k + 1;
                                                Debug_Col = 7 + 1;
                                                throw new Exception();
                                            }
                                        }
                                    }
                                }
                                // 리스트에 추가
                                Excel_Sheet.List_Repeater.Add(Excel_Repeater);
                            }
                        }
                        // 리스트에 추가
                        _Data.List_ExcelPoint.Add(Excel_Sheet);
                    }
                }

                ///
                /// 3. 포인트 위치 정보에 따라 실제로 사용한는 위치 코드값을 재정리
                /// 실제로 사용되는 위치코드만 재정리
                /// 

                Code_Postion_Create();

                // 단, 엑셀시트 클래스안에 중계기클래스가 없다면 잘못된 포맷이다
                int RepeterAllCount = 0;
                foreach (_Excel_Sheet Excel_Sheet in _Data.List_ExcelPoint)
                    foreach (_Excel_Repeater Excel_Repeater in Excel_Sheet.List_Repeater)
                        RepeterAllCount++;
                if (RepeterAllCount == 0)
                {
                    // 파일 포맷이 잘못되었습니다
                    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.FailFormatInform, 0);
                    return false;
                }

                /////
                ///// 4. 그룹 정보 저장                
                /////

                //if (Import_Point_GetGroup(worksheets, Connection) == false)
                //{
                //    // 연동그룹 시트가 잘못되었습니다
                //    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.FailGroupInform, 0);
                //    return false;
                //}

                /////
                ///// 5. 맵 정보 저장                
                /////

                //if (Import_Point_GetMap(worksheets, Connection) == false)
                //{
                //    // 연동설정 시트가 잘못되었습니다
                //    _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 250, 150, _Text.FailMapInform, 0);
                //    return false;
                //}

                // 엑셀 읽기 세션 해제
                if (Connection != null) Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                string Error = " 시트명:" + Debug_SheetName + " 행:" + Debug_Row + " 열:" + Debug_Col;

                // 추가 메세지가 필요한 경우                
                string Message = null;

                // 추가 메세지가 없는 경우에는 "데이타가 잘못되었습니다" 문구 출력
                if (Debug_EtcMessage != null)
                    Message = Debug_EtcMessage + Error;
                else
                    Message = _Text.FailDataInform + Error;

                // 데이타가 잘못되었습니다
                _Popup.Create(Popup_Type.Confirm, Popup_Style.Normal, _Text.Warnning, 600, 150, Message, 0);

                // LOG
                _Event.DebugView_SendMessage_Write(_Text.NotReadExcelFile + Error + " 의 정보를 확인해주세요 " + e.ToString());

                // 엑셀 읽기 세션 해제
                if (Connection != null) Connection.Close();

                return false;
            }
        }

        // Export  
        public static void Export_Point(string FileFullPath)
        {

        }
    }
}