CS 그리드 추가

public class GridRowDomain : INotifyPropertyChanged
    {
        private static DataDict _dataDict = new DataDict();
        private static ObservableCollection<string> _domainClassList;
        public ObservableCollection<string> DomainClassList { get { return _domainClassList; } set { _domainClassList = value; NotifyPropChanged("DomainClassList"); } }
        private static ObservableCollection<DomainDataType> _dataTypeList;
        public ObservableCollection<DomainDataType> DataTypeList { get { return _dataTypeList; } set { _dataTypeList = value; NotifyPropChanged("DataTypeList"); } }
        private ObservableCollection<DataDict._StdTerm> _parsedResultList;
        public ObservableCollection<DataDict._StdTerm> ParsedResultList
        {
            get { return _parsedResultList; }
            set
            {
                _parsedResultList = value;
                NotifyPropChanged("ParsedResultList");
            }
        }


        //내부 보유 요청번호
        private int _reqNo;             public int ReqNo { get { return _reqNo; } set { _reqNo = value; } }
        private bool _checked = false;  public bool Checked {get { return _checked; } set { _checked = value; NotifyPropChanged("Checked"); } }
        private string _statCd;         public string Status { get { return _statCd; } set { _statCd = value; NotifyPropChanged("Status"); } }
        private string _parseResult;    private string ParseResult { get { return _parseResult; } set { _parseResult = value; ; NotifyPropChanged("CheckResult"); } }
        private string _lengthOption;
        private bool IsNullOrEmpty(string str) { return (str == null || str == ""); }
        public string CheckResult
        {
            get
            {
                string strResult = "";
                //ParseResult = 정상, 
                if(! (this.ParseResult.Equals("정상")) )
                {
                    strResult = this.ParseResult;
                }
                else if(IsNullOrEmpty(this.DomainClass))
                {
                    strResult = "미입력(유형)";
                } 
                else if(IsNullOrEmpty(this.DataType))
                {
                    strResult = "미입력(데이터타입)";
                }
                else if(this._lengthOption =="Y" && IsNullOrEmpty(this.DataLength))
                {
                    strResult = "미입력(데이터길이)";
                }
                else if(IsNullOrEmpty(this.Definition))
                {
                    strResult = "미입력(정의)";
                }
                else if (this.Status.Contains("중복"))
                {
                    strResult = "중복";
                }

                else
                {
                    strResult = this.ParseResult;
                }
                return strResult;
            }
        }
        private string _infoTypeName;   public string InfoTypeName { get { return _infoTypeName; } set { this._infoTypeName = value; NotifyPropChanged("InfoTypeName"); } }

        private string _domainName;
        public string DomainName
        {
            get { return _domainName; }
            set
            {
                _domainName = value;
                //용어가 삭제 또는 공백인 경우
                if(_domainName == null || _domainName=="")
                {
                    //_parsedTermList.Clear();
                    this.ReqId = "";
                    this.Status = "신청전";
                    this.ParseResult = "";
                    this.ParsedVocas = "";
                    this.ParsedResultList.Clear();
                    this.InfoTypeName = "";
                }
                else
                {
                    _domainName = _domainName.ToUpper();

                    List<DataDict._StdTerm> parsedList = _dataDict.GetParsedTermList(_domainName, false);
                    this.ParsedResultList.Clear();
                    this.ParsedResultList = new ObservableCollection<DataDict._StdTerm>(parsedList);

                    //terms.ForEach(t => _parsedTermList.Add(t.ParsedTerm));

                    if (parsedList.Count > 0)
                    {
                        this.ParseResult = parsedList[0].CheckResult;
                        //선택이 필요한 경우 단어분해를 공백으로
                        this.ParsedVocas = parsedList.Count == 1 ? parsedList[0].ParsedTerm : ""; // _parsedTermList[0];
                    }
                    try
                    {
                        this.DomainClass = this.DomainClassList.First(item => item.Equals(DomainName.Substring(DomainName.Length - item.Length)));
                    }
                    catch(Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                    }
                    this.InfoTypeName = this.DomainName + "_" + this.DataTypeAbbr + this.DataLength;

                    //편집으로 생성된 경우 중복 검사
                    //Debug.WriteLine(this.Status);
                    if (this.Status == "신청전" || this.Status == "")
                    {
                        GridRowDomain findDomain = SearchDomain(this._domainName);
                        if (findDomain != null)
                        {
                            this.ParsedVocas = findDomain.ParsedVocas;
                            //this.ParsedResultList.Clear();
                            this.InfoTypeName = findDomain.InfoTypeName;
                            this.DomainClass = findDomain.DomainClass;
                            this.DataType = findDomain.DataType;
                            this.DataLength = findDomain.DataLength;
                            this.EngName = findDomain.EngName;
                            this.Definition = findDomain.Definition;

                            if (findDomain.ReqNo == 1)
                            {
                                this.Status = "중복(표준)";
                                MessageBox.Show("표준에 존재합니다.");
                            }
                            else
                            {
                                this.Status = "중복(신청)";
                                MessageBox.Show("신청내역에 존재합니다.");
                            }
                            //return; //인포타입 다른 것을 등록할 수 있음... 경고만 표시
                        }
                    }


                }
                this.NotifyPropChanged("DomainName");
            }
        }
        public string _domainClass;     public string DomainClass { get { return _domainClass; }  set { _domainClass = value; NotifyPropChanged("DomainClass"); } }
        private string _parsedVocas;
        public string ParsedVocas
        {
            get { return _parsedVocas; }
            set
            {
                _parsedVocas = value;
                NotifyPropChanged("ParsedVocas");
                if (_parsedVocas == null || _parsedVocas.Length < 1)
                {
                    this.EngName = "";
                    //this.Definition = "";
                }
                else
                {
                    try
                    {
                        DataDict._StdTerm parsedResult = ParsedResultList.First(t => t.ParsedTerm.Equals(_parsedVocas));
                        if (parsedResult != null)
                        {
                            this.ParseResult = parsedResult.CheckResult;
                            this.EngName = parsedResult.EngTermName;
                            if (this.ParseResult.Equals("[선택필요]")) this.ParseResult = "정상";

                        }
                    }
                    catch(Exception ex)
                    {
                        MessageBox.Show(ex.Message, "ParsedVocas", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    
                }
            }
        }
        private string _engName;        public string EngName { get { return _engName; } set { _engName = value; NotifyPropChanged("EngName"); } }
        private string _dataType;
        public string DataType
        {
            get { return _dataType; }
            set
            {
                _dataType = value;
                DomainDataType dType = this.DataTypeList.First(item => item.DataType.Equals(_dataType));
                _dataTypeAbbr = dType.AbbrName;
                _lengthOption = dType.LengthOption;
                if (this._lengthOption == "N")
                {
                    this.DataLength = "";
                }
                InfoTypeName = DomainName + "_" + DataTypeAbbr + DataLength;
                NotifyPropChanged("DataType");
                NotifyPropChanged("DataTypeLength");
            }
        }
        private string _dataTypeAbbr;   public string DataTypeAbbr {  get { return _dataTypeAbbr; } }
        private string _dataLength;
        public string DataLength
        {
            get { return _dataLength; }
            set
            {
                if(this._lengthOption=="Y")
                {
                    _dataLength = value;
                }
                else
                {
                    _dataLength = "";
                }
                
                InfoTypeName = DomainName + "_" + DataTypeAbbr + DataLength;
                NotifyPropChanged("DataLength");
                NotifyPropChanged("DataTypeLength");
            }
        }
        public string DataTypeLength 
        {
            get
            {
                string typeLen = this._dataType;
                //if (this._dataLength != null && this._dataLength != "") typeLen += "(" + this._dataLength + ")";
                if (this._lengthOption=="Y") typeLen += "(" + this._dataLength + ")";
                return typeLen;
            }
        }
        public string DataTypeLengthP
        {
            get
            {
                return DataTypeLength.Replace("VARCHAR(", "VARCHAR2(");
            }
        }

        private string _definition;     public string Definition { get { return _definition; } set { _definition = value; NotifyPropChanged("Definition"); } }

        public string ReqId { get; set; }
        public DateTime ReqDt { get; set; }
        public string StatDt { get; set; }
        private string _statRmk;        public string StatRmk { get { return _statRmk; } set { _statRmk = value; NotifyPropChanged("StatRmk"); } }

        public GridRowDomain()
        {
            //_parsedTermList_old = new ObservableCollection<string>();
            ParsedResultList = new ObservableCollection<DataDict._StdTerm>();
            
            _statCd = "신청전";
            _parseResult = "";
            this.ReqDt = DateTime.Now;

            this.InitComboDataTypeList();
            this.InitComboDomainClassList();

        }

        public GridRowDomain(int reqNo, string infotypeName, string domainName
            , string domainClass, string engName, string parsedVocas
            , string dataType, string dataLength, string definition
            , string reqId, DateTime reqDt, string statCd, string statRmk, string statDt
            , string checkReault = "정상") : this()
        {
            this.ReqNo = reqNo;
            this.Status = statCd; // 상태값을 우선 변경해야 명칭 입력/변경에 대한 처리시 참조됨
            this.ParseResult = checkReault;

            this._domainName = domainName;
            this._domainClass = domainClass;
            this._engName = engName;
            this._parsedVocas = parsedVocas;
            this.ParsedResultList.Add(new DataDict._StdTerm(domainName, parsedVocas));
            this._infoTypeName = infotypeName;
            this._dataType = dataType;
            this._dataLength = dataLength;
            if(dataLength != null && dataLength.Length > 0)
            {
                this._lengthOption = "Y";
            }
            this._definition = definition;

            this.ReqId = reqId;
            this.ReqDt = reqDt;
            this.StatDt = statDt;
            this.StatRmk = statRmk;
        }

        private void InitComboDataTypeList()
        {
            if(this.DataTypeList == null)
            {
                this.DataTypeList = new ObservableCollection<DomainDataType>();

                string strSQL = "select cm_cd, cd_nm" +
                    "    , att1 AbbrName" +
                    "    , att2 LengthOption " +
                    " from tb_dm_cm_cd where grp_cd = 'DOMAIN_DATATYPE' and use_yn = 'Y' order by ord_no ";
                OleDbCommand dbCmd = new OleDbCommand(strSQL, _dataDict.GetConnection());
                OleDbDataReader dbReader = dbCmd.ExecuteReader();
                if (dbReader.HasRows)
                {
                    while (dbReader.Read())
                    {
                        DomainDataType item = new DomainDataType();
                        item.DataType = dbReader.GetString(0);
                        item.AbbrName = dbReader.GetString(2);
                        item.LengthOption = dbReader.GetString(3);
                        this.DataTypeList.Add(item);
                    }
                }
                dbReader.Close();
                dbCmd.Dispose();
            }
        }

        private void InitComboDomainClassList()
        {
            if (this.DomainClassList == null)
            {
                this.DomainClassList = new ObservableCollection<string>();

                string strSQL = "select cm_cd, cd_nm, att1 from tb_dm_cm_cd where grp_cd = 'DOMAIN_CLASS' and use_yn = 'Y' order by ord_no ";
                OleDbCommand dbCmd = new OleDbCommand(strSQL, _dataDict.GetConnection());
                OleDbDataReader dbReader = dbCmd.ExecuteReader();
                if (dbReader.HasRows)
                {
                    while (dbReader.Read())
                    {   
                        this.DomainClassList.Add(dbReader.GetString(0));
                    }
                }
                dbReader.Close();
                dbCmd.Dispose();
            }
        }

        public GridRowDomain SearchDomain(string domainName)
        {
            GridRowDomain domain = null;
            string strSQL =
                "select 1 Location, a.i_name, a.d_name, a.d_class, a.d_ename, a.d_parsed, a.d_dtype, a.d_dlen, a.d_ldtype_len, a.d_desc " +
                "     , a.modfr, a.moddt " +
                "  from dm_std_domain a " +
                " where a.d_name = :domain1 " +
                "union all " +
                "select 2 Location, a.i_name, a.d_name, a.d_class, a.d_ename, a.d_parsed, a.d_dtype, a.d_dlen, a.d_ldtype_len, a.d_desc " +
                "     , a.req_id, a.req_dt " +
                "  from tb_dm_req_domain a " +
                " where a.d_name = :domain2 and stat_cd in ('신청','검토')" +
                " order by 1"
                ;
            OleDbCommand dbCmd = new OleDbCommand(strSQL, _dataDict.GetConnection());
            dbCmd.Parameters.Add(":domain1", OleDbType.VarChar).Value = domainName;
            dbCmd.Parameters.Add(":domain2", OleDbType.VarChar).Value = domainName;
            //dbCmd.Parameters[":termName"].Value = termName;

            OleDbDataReader dbReader = dbCmd.ExecuteReader();

            if (dbReader.HasRows)
            {
                if (dbReader.Read())
                {
                    //string term, string engTerm, string parsedTerm, string domainName, string infotypeName, string dataTypeLen
                    domain = new GridRowDomain(
                            (int)dbReader.GetDecimal(0),    /* 테이블 구분 번호 1.표준, 2.신청 */
                            dbReader.GetString(1),          /* i_name */
                            dbReader.GetString(2),          /* d_name */
                            dbReader.GetString(3),          /* d_class */
                            dbReader.GetString(4),          /* d_ename */
                            dbReader.GetString(5),          /* d_parsed */
                            dbReader.GetString(6),          /* d_dtype */
                            (dbReader.IsDBNull(7) ? "": dbReader.GetString(7)),          /* d_dlen */
                                                            /* dbReader.GetString(8),  // d_ldtype_len */
                            dbReader.GetString(9),          /* definition(d_desc) */
                            dbReader.GetString(10),         /* reqid */
                            dbReader.GetDateTime(11),       /* modify datetime */
                            "", "", "", "중복신청"          /* statcd, statRmk, statDt, checkResult */
                            );
                }
            }
            dbReader.Close();
            dbCmd.Dispose();

            return domain;
        }

        #region INotifyPropertyChanged Members 구현
        /// <summary>
        /// INotifyPropertyChanged 인터페이스의 PropertyChanged 이벤트 구현
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropChanged(string prop)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(prop));
                if(prop.Equals("ParseResult") || prop.Equals("DomainClass") || prop.Equals("DataType") || prop.Equals("DataLength") || prop.Equals("Definition"))
                {
                    PropertyChanged(this, new PropertyChangedEventArgs("CheckResult"));
                }
            }
                
        }

        #endregion
    }
CS 그리드 추가

DB CAFE
