Beispiel #1
0
 public List <S> Select <S>(Expression <Func <T, S> > selector)
 {
     using (ERPEntities entities = new ERPEntities())
     {
         return(entities.Set <T>().Select(selector).ToList());
     }
 }
Beispiel #2
0
        public static void SetMenuItemsByAccount(this TreeView treeView,
                                                 out List <계정과목등록> MenuItems)
        {
            using (ERPEntities entity = new ERPEntities())
            {
                MenuItems = entity.계정과목등록.ToList();

                foreach (var item in MenuItems)
                {
                    if (item.PrentKey == null)
                    {
                        treeView.Nodes.Add(item.CodeNum, item.Title);
                    }
                }

                foreach (var item in MenuItems)
                {
                    int check = treeView.Nodes.Find(item.PrentKey, true).Length;
                    if (check > 0)
                    {
                        int inputNum = treeView.Nodes.Find(item.PrentKey, true).Length - 1;
                        treeView.Nodes.Find(item.PrentKey, true)[inputNum].Nodes.Add(item.CodeNum, item.Title);
                    }
                }
            }
        }
        public MES공정별수량 Get공정별수량(string 관리번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var q = from x in context.MES공정별수량
                        where x.관리번호 == 관리번호
                        select x;

                MES공정별수량 MES공정별수량c = new MES공정별수량();

                foreach (var item in q)
                {
                    MES공정별수량c.제품번호   = item.제품번호;
                    MES공정별수량c.관리번호   = item.관리번호;
                    MES공정별수량c.절단생산수량 = item.절단생산수량;
                    MES공정별수량c.절단불량수량 = item.절단불량수량;
                    MES공정별수량c.벤딩생산수량 = item.벤딩생산수량;
                    MES공정별수량c.벤딩불량수량 = item.벤딩불량수량;
                    MES공정별수량c.드릴생산수량 = item.드릴생산수량;
                    MES공정별수량c.드릴불량수량 = item.드릴불량수량;
                    MES공정별수량c.용접생산수량 = item.용접생산수량;
                    MES공정별수량c.용접불량수량 = item.용접불량수량;
                    MES공정별수량c.실적시간   = item.실적시간;
                    MES공정별수량c.완료유무   = item.완료유무;
                }

                return(MES공정별수량c);
            }
        }
Beispiel #4
0
 public List <T> GetAll()
 {
     using (ERPEntities entities = new ERPEntities())
     {
         return(entities.Set <T>().ToList());
     }
 }
Beispiel #5
0
 public int GetCount()
 {
     using (ERPEntities entities = new ERPEntities())
     {
         return(entities.Set <T>().Count());
     }
 }
Beispiel #6
0
 public void Check(string id, string pwd, out int employeeCnt)
 {
     using (ERPEntities entity = new ERPEntities())
     {
         employeeCnt = entity.사원등록.Where(x => x.사원코드 == id && x.암호 == pwd).ToList().Count;
     }
 }
 public void Set현장실적현황()
 {
     using (ERPEntities context = new ERPEntities())
     {
         //context.SaveChanges
     }
 }
Beispiel #8
0
 public void Insert(T entity)
 {
     using (ERPEntities entities = new ERPEntities())
     {
         entities.Set <T>().Add(entity);
         entities.SaveChanges();
     }
 }
Beispiel #9
0
 public void Update(T entity)
 {
     using (ERPEntities entities = new ERPEntities())
     {
         entities.Entry(entity).State = EntityState.Modified;
         entities.SaveChanges();
     }
 }
Beispiel #10
0
 public void Delete(T entity)
 {
     using (ERPEntities entities = new ERPEntities())
     {
         entities.Entry(entity).State = EntityState.Deleted;
         entities.SaveChanges();
     }
 }
Beispiel #11
0
        public void Check(string id, out int employeeCnt, out string employeeName)
        {
            using (ERPEntities entity = new ERPEntities())
            {
                employeeCnt = entity.사원등록.Where(x => x.사원코드 == id).ToList().Count;

                employeeName = entity.사원등록.Where(x => x.사원코드 == id).Select(x => x.사원명).ToList().FirstOrDefault();
            }
        }
Beispiel #12
0
        public List <작업지시현황> GetAll2()
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.작업지시현황
                            select x;

                return(query.ToList());
            }
        }
Beispiel #13
0
        public List <MES투입현황> Get투입현황()
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.MES투입현황
                            orderby x.투입일 ascending
                            select x;

                return(query.ToList());
            }
        }
Beispiel #14
0
        public List <제품> Get제품_All()
        {
            using (ERPEntities context = new ERPEntities())
            {
                var q = from x in context.제품
                        select x;


                return(q.ToList());
            }
        }
Beispiel #15
0
        public List <MES투입현황> Get투입현황_Rows(string 관리번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var q = from a in context.MES투입현황
                        where a.관리번호 == 관리번호
                        select a;

                return(q.ToList());
            }
        }
        public List <MES현장실적현황> GetALL()
        {
            using (ERPEntities context = new ERPEntities())
            {
                var 현장실적query = from x in context.MES현장실적현황
                                select x;


                return(현장실적query.ToList());
            }
        }
Beispiel #17
0
        public int Get지시수량(string 제품번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.작업지시현황
                            select x;

                int 지시수량 = 0;

                foreach (var item in query)
                {
                    if (item.제품번호 == 제품번호)
                    {
                        지시수량 = item.수량;
                    }
                }

                return(지시수량);
            }
        }
        public string Get현장실적현황_설비명(string 관리번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var 현장실적query = from x in context.MES현장실적현황
                                select x;


                return(현장실적query.Where(w => w.관리번호 == 관리번호).Select(s => s.설비명).ToString());
                //string 설비명 = null;

                //foreach(var item in 현장실적query)
                //{
                //    if (item.관리번호 == 관리번호)
                //        설비명 = item.설비명;
                //}

                //return 설비명;
            }
        }
Beispiel #19
0
        public string 공정순서_공정번호(string 제품번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.공정순서
                            select x;

                string 공정번호 = null;

                foreach (var item in query)
                {
                    if (item.제품번호 == 제품번호)
                    {
                        공정번호 = item.공정번호.ToString();
                    }
                }

                return(공정번호);
            }
        }
Beispiel #20
0
        public string Get자재번호(string 제품번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.자재명세서
                            select x;

                string 자재번호 = null;

                foreach (var item in query)
                {
                    if (item.제품번호 == 제품번호)
                    {
                        자재번호 = item.자재번호;
                    }
                }

                return(자재번호);
            }
        }
Beispiel #21
0
        public string Get제품_제품명(string 제품번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.제품
                            select x;

                string 제품명 = null;

                foreach (var item in query)
                {
                    if (item.제품번호 == 제품번호)
                    {
                        제품명 = item.제품명;
                    }
                }

                return(제품명);
            }
        }
Beispiel #22
0
        public int Get불량수량(string 자재번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.불량상세정보
                            select x;

                int 불량수량 = 0;

                foreach (var item in query)
                {
                    if (item.자재번호 == 자재번호)
                    {
                        불량수량 = item.불량수량;
                    }
                }

                return(불량수량);
            }
        }
Beispiel #23
0
        public int Get제품_규격(string 제품번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.제품
                            select x;

                int 규격 = 0;

                foreach (var item in query)
                {
                    if (item.제품번호 == 제품번호)
                    {
                        규격 = item.외경;
                    }
                }

                return(규격);
            }
        }
Beispiel #24
0
        public string 공정_공정명(string 공정번호)
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from x in context.공정
                            select x;



                string 공정명 = null;

                foreach (var item in query)
                {
                    if (item.공정번호.ToString() == 공정번호)
                    {
                        공정명 = item.공정명;
                    }
                }

                return(공정명);
            }
        }
Beispiel #25
0
        public Dictionary <string, int> Get투입현황_투입개수()
        {
            using (ERPEntities context = new ERPEntities())
            {
                var query = from p in context.MES투입현황
                            group p by p.제품번호 into g
                            select new
                {
                    제품번호         = g.Key,
                    ProductCount = g.Count()
                };

                Dictionary <string, int> list = new Dictionary <string, int>();

                foreach (var item in query)
                {
                    list.Add(item.제품번호.Trim(), item.ProductCount);
                }


                return(list);
            }
        }
Beispiel #26
0
        private void BtnWorkStart_Click(object sender, EventArgs e)
        {
            if (WorkStart == false)
            {
                if (lbl관리번호.Text == "")
                {
                    MessageBox.Show("작업할 Item을 선택하세요");
                    return;
                }

                string 품번   = grid작업지시목록.Rows[grid작업지시목록.CurrentCell.RowIndex].Cells[0].Value.ToString();
                string 관리번호 = lbl관리번호.Text;
                int    i    = 0;
                string 제품번호 = null;
                while (i < 11)
                {
                    if (grid작업지시목록.Rows[grid작업지시목록.CurrentCell.RowIndex].Cells[0].Value.ToString() != null &&
                        grid작업지시목록.Rows[grid작업지시목록.CurrentCell.RowIndex].Cells[i + 1].Value.ToString() != null)
                    {
                        제품번호 = grid작업지시목록.Rows[grid작업지시목록.CurrentCell.RowIndex].Cells[i + 1].Value.ToString();
                        break;
                    }

                    i = i + 5;
                }

                UserControlList.workStatus.lbl품목번호.Text = 품번;
                UserControlList.workStatus.lbl관리번호.Text = 관리번호;

                using (ERPEntities entity = new ERPEntities())
                {
                    var 품목정보list = entity.품목정보.Where(x => x.품목번호 == 품번).ToList();
                    var 투입현황list = entity.MES투입현황.Where(x => x.관리번호 == 관리번호).ToList();
                    var 제품list   = entity.제품.Where(x => x.제품번호 == 제품번호).ToList();

                    UserControlList.workStatus.lbl지시수량.Text   = 투입현황list[0].투입수량.ToString();
                    UserControlList.workStatus.lbl규격.Text     = 품목정보list[0].외경.ToString();
                    UserControlList.workStatus.lbl작업시작시간.Text = DateTime.Now.ToString();

                    if (제품list.Count != 0)
                    {
                        UserControlList.workStatus.lbl품명.Text = 제품list[0].제품명.ToString();
                    }

                    UserControlList.workStatus.투입공정현황 = 투입현황list[0].공정.ToString();
                }

                if (UcWorkStart != null)
                {
                    UcWorkStart(sender, e);
                }

                WorkStart = true;
                UserControlList.workStatus.공정상태();
                UserControlList.workStatus.grid저장_호출();
            }

            else
            {
                MessageBox.Show("작업이 진행중입니다.");
                UcWorkStart("진행", e);
                WorkStart = true;
            }
        }
Beispiel #27
0
        private void Btn조회_Click(object sender, EventArgs e)
        {
            using (ERPEntities context = new ERPEntities())
            {
                grid불량실적조회.Rows.Clear();

                var q = from a in context.MES불량실적현황
                        select a;

                var 실적q = from a in context.MES현장실적현황
                          select a;

                var rq = from a in q
                         join b in 실적q on a.관리번호 equals b.관리번호
                         select new
                {
                    a.관리번호,
                    a.등록시간,
                    a.불량수량,
                    a.비고,
                    a.실적번호,
                    a.제품번호,
                    b.작업자,
                    b.설비명,
                    b.공정명
                };


                if (!tbx품목번호.Text.IsNullOrEmpty())
                {
                    rq = from a in rq
                         where a.제품번호.Contains(tbx품목번호.Text.ToString())
                         select a;
                }


                if (dtFirst != null && dtLast != null)
                {
                    DateTime Startday = DateTime.Parse(dtFirst.Value.ToString("yyyy-MM-dd"));
                    DateTime Endday   = DateTime.Parse(dtLast.Value.ToString("yyyy-MM-dd"));

                    rq = from b in rq
                         where Startday <= b.등록시간 &&
                         Endday >= b.등록시간
                         select b;
                }


                if (!((string)cbb공정.SelectedItem).IsNullOrEmpty())
                {
                    rq = from a in rq
                         where ((string)cbb공정.SelectedItem).Contains(a.공정명)
                         select a;
                }

                if (!tbx관리번호.Text.IsNullOrEmpty())
                {
                    rq = from a in rq
                         where a.관리번호.Contains(tbx관리번호.Text)
                         select a;
                }


                if (!tbx사원번호.Text.IsNullOrEmpty())
                {
                    rq = from a in rq
                         where (from x in context.사원등록
                                where a.작업자 == x.사원명
                                select x.사원코드).Contains(tbx사원번호.Text)
                         select a;
                }

                if (rq.Count() <= 0)
                {
                    MessageBox.Show("검색된 데이터가 없습니다");
                    return;
                }

                int ColumnIndex = 0;
                int 불량실적행번호     = 0;

                foreach (var item in rq)
                {
                    ColumnIndex = 0;

                    grid불량실적조회.Rows.Add();
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.관리번호;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.제품번호;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.불량수량;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.공정명;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.작업자;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.등록시간;
                    grid불량실적조회.Rows[불량실적행번호].Cells[ColumnIndex++].Value = item.비고;

                    불량실적행번호++;
                }
            }
        }
Beispiel #28
0
        private void Btn조회_Click(object sender, EventArgs e)
        {
            using (ERPEntities context = new ERPEntities())
            {
                grid상세실적조회.Rows.Clear();

                var q = from a in context.MES현장실적현황
                        select a;

                if (!tbx제품번호.Text.IsNullOrEmpty())
                {
                    q = from a in q
                        where a.제품번호.Contains(tbx제품번호.Text.ToString())
                        select a;
                }

                if (!((string)cbb공정.SelectedItem).IsNullOrEmpty())
                {
                    q = from a in q
                        where ((string)cbb공정.SelectedItem).Contains(a.공정명)
                        select a;
                }


                if (dtFirst != null && dtLast != null)
                {
                    DateTime Startday = DateTime.Parse(dtFirst.Value.ToString("yyyy-MM-dd"));
                    DateTime Endday   = DateTime.Parse(dtLast.Value.ToString("yyyy-MM-dd"));

                    q = from b in q
                        where Startday <= b.실적등록시간 &&
                        Endday >= b.실적등록시간
                        select b;
                }

                if (!tbx관리번호.Text.IsNullOrEmpty())
                {
                    q = from a in q
                        where a.관리번호.Contains(tbx관리번호.Text.ToString())
                        select a;
                }

                if (!tbx사원번호.Text.IsNullOrEmpty())
                {
                    q = from a in q
                        where (from x in context.사원등록
                               where a.작업자 == x.사원명
                               select x.사원코드).Contains(tbx사원번호.Text.ToString())
                        select a;
                }

                var 완료관리번호 = q.Where(a => a.완료유무 == true).Select(a => a.관리번호).Distinct().ToList();

                List <MES현장실적현황> 현장실적헌황s = new List <MES현장실적현황>();
                foreach (var 완료item in 완료관리번호)
                {
                    foreach (var 실적item in q)
                    {
                        if (실적item.관리번호 == 완료item)
                        {
                            현장실적헌황s.Add(실적item);
                        }
                    }
                }

                int ColumnIndex = 0;
                int 생산실적행번호     = 0;

                if (현장실적헌황s.Count() <= 0)
                {
                    MessageBox.Show("검색된 데이터가 없습니다");
                    return;
                }

                foreach (var item in 현장실적헌황s)
                {
                    ColumnIndex = 0;

                    grid상세실적조회.Rows.Add();
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.관리번호;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.제품번호;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.실적수량;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.불량수량;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.공정명;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.작업자;
                    grid상세실적조회.Rows[생산실적행번호].Cells[ColumnIndex++].Value = item.실적등록시간;

                    생산실적행번호++;
                }
            }
        }
Beispiel #29
0
        public List <공정시작수량Data> Get공정시작수량()
        {
            using (ERPEntities context = new ERPEntities())
            {
                List <수주현황> 수주현황List = new List <수주현황>();

                var 수주q = (from h in context.수주
                           group h by new { h.제품번호, h.납기일 } into hh
                           orderby hh.Key
                           //where hh.Key.제품번호 == 제품번호
                           select new
                {
                    hh.Key.제품번호,
                    hh.Key.납기일,
                    주문수량 = hh.Sum(s => s.주문수량),
                }).OrderBy(o => o.납기일);

                var 품번 = 수주q.Select(x => x.제품번호).Distinct();

                var 제품q = (from a in context.제품
                           select new
                {
                    a.제품번호,
                    a.재고량,
                    a.안전재고량,
                    a.리드타임,
                    a.LOT수량
                });

                var 제품s = 제품q.Where(x => 품번.Contains(x.제품번호)).ToList();

                List <공정시작수량Data> 공정시작수량list = new List <공정시작수량Data>();

                foreach (var 제품item in 제품s)
                {
                    int      _1차필요수량   = 0;
                    int      _2차필요수량   = 0;
                    int      LOT수량     = 0;
                    string   제품번호      = null;
                    DateTime _1차공정시작날짜 = new DateTime();
                    DateTime _2차공정시작날짜 = new DateTime();
                    Boolean  _1차공정시작   = false;
                    Boolean  _2차공정시작   = false;

                    _1차필요수량 = 제품item.안전재고량 - 제품item.재고량;
                    LOT수량   = 제품item.LOT수량;
                    제품번호    = 제품item.제품번호;

                    foreach (var 수주item in 수주q)
                    {
                        if (수주item.제품번호 == 제품번호)
                        {
                            _1차필요수량 += 수주item.주문수량;

                            if ((_1차필요수량 > 0) && (_1차공정시작 == false))
                            {
                                _1차공정시작   = true;
                                _1차공정시작날짜 = 수주item.납기일;
                            }


                            if (_1차필요수량 > LOT수량 && _2차공정시작 == false)
                            {
                                _2차공정시작   = true;
                                _2차공정시작날짜 = 수주item.납기일;
                                _2차필요수량   = _1차필요수량 - LOT수량;
                                _1차필요수량   = LOT수량;
                            }
                            else if (_2차공정시작 == true)
                            {
                                _2차필요수량 += 수주item.주문수량;
                            }


                            if (_2차필요수량 > LOT수량)
                            {
                                break;
                            }

                            if (_1차공정시작 == false)
                            {
                                //수주item.납기일 = (DateTime)null;
                            }
                        }
                    }
                    if (_1차공정시작 == true)
                    {
                        공정시작수량Data 공정시작수량c = new 공정시작수량Data
                        {
                            제품번호    = 제품번호,
                            _1차공정시작 = _1차공정시작,
                            //_1차관리번호 =
                            _1차필요수량   = _1차필요수량,
                            _1차공정시작날짜 = DateTime.Parse(_1차공정시작날짜.ToShortDateString()),
                            _2차공정시작   = _2차공정시작,
                            //_2차관리번호 =
                            _2차필요수량   = _2차필요수량,
                            _2차공정시작날짜 = DateTime.Parse(_2차공정시작날짜.ToShortDateString()),
                            LOT수량     = LOT수량
                        };

                        공정시작수량list.Add(공정시작수량c);
                    }
                }

                List <공정시작수량Data> 공정시작수량list_2 = new List <공정시작수량Data>();
                공정시작수량list_2 = 공정시작수량list.OrderBy(x => x._1차공정시작날짜).ToList();



                //foreach (var item in 수주q)
                //{
                //    수주현황 수주현황c = new 수주현황()
                //    {
                //        납기일 = item.납기일,
                //        제품번호 = item.제품번호,
                //        주문수량 = item.주문수량
                //    };

                //    수주현황List.Add(수주현황c);
                //}

                int 순위cnt = 1;

                공정시작수량list_2[0].순위 = 1;

                for (int i = 0; i < 공정시작수량list_2.Count() - 1; i++)
                {
                    if (공정시작수량list_2[i + 1]._1차공정시작날짜 == null)
                    {
                        break;
                    }

                    if (공정시작수량list_2[i]._1차공정시작날짜 != 공정시작수량list_2[i + 1]._1차공정시작날짜)
                    {
                        순위cnt++;
                    }

                    공정시작수량list_2[i + 1].순위 = 순위cnt;
                }


                return(공정시작수량list_2);


                //foreach (var item in 수주q)
                //{
                //    수주현황 items = new 수주현황()
                //    {
                //        납기일 = item.납기일,
                //        품번 = item.제품번호,
                //        수량 = item.주문수량
                //    };

                //    수주현황List.Add(items);
                //}



                //var 제품q = from a in context.제품
                //         // where a.제품번호 == 제품번호
                //          select new
                //          {
                //              a.재고량,
                //              a.안전재고량,
                //              a.리드타임,
                //              a.LOT수량
                //          };

                //int _1차필요수량 = 0;
                //int _2차필요수량 = 0;
                //int LOT수량 = 0;
                //DateTime _1차공정시작날짜 = new DateTime();
                //DateTime _2차공정시작날짜 = new DateTime();
                //Boolean _1차공정시작 = false;
                //Boolean _2차공정시작 = false;

                //foreach (var 제품item in 제품q)
                //{
                //    _1차필요수량 = 제품item.안전재고량 - 제품item.재고량;
                //    LOT수량 = 제품item.LOT수량;

                //    foreach (var 수주item in 수주q)
                //    {
                //        if ((_1차필요수량 > 0) && (_1차공정시작 == false))
                //        {
                //            _1차공정시작 = true;
                //            _1차공정시작날짜 = 수주item.납기일.AddDays(-제품item.리드타임);
                //        }

                //        _1차필요수량 += 수주item.주문수량;

                //        if((_1차필요수량 >= 제품item.LOT수량 - 제품item.안전재고량 + 제품item.재고량)  && (_2차공정시작 == false) && (_1차공정시작 == true))
                //        {
                //            _2차공정시작 = true;
                //            _2차공정시작날짜 = 수주item.납기일.AddDays(-제품item.리드타임);
                //        }
                //    }

                //    if (_2차공정시작 == true)
                //    {
                //        _2차필요수량 = _1차필요수량 - 제품item.LOT수량;
                //        _1차필요수량 = 제품item.LOT수량;
                //    }
                //}

                ////string _1차관리번호 = $"{_1차공정시작날짜.ToString()}{001}";
                ////string _2차관리번호 = $"{_2차공정시작날짜.ToString()}{001}";

                ////공정시작수량Data 공정시작수량c = new 공정시작수량Data
                ////{

                ////    제품번호 = 제품번호,
                ////    _1차공정시작 = _1차공정시작,
                ////    //_1차관리번호 =
                ////    _1차필요수량 = _1차필요수량,
                ////    _1차공정시작날짜 = _1차공정시작날짜,

                ////    _2차공정시작 = _2차공정시작,
                ////    //_2차관리번호 =
                ////    _2차필요수량 = _2차필요수량,
                ////    _2차공정시작날짜 = _2차공정시작날짜,
                ////    LOT수량 = LOT수량

                ////};

                ////return 공정시작수량c;

                ////제품번호, 1차공정시작, 1차필요수량, 1차공정시작날짜, 2차공정시작, 2차필요수량, 2차공정시작날짜, LOT수량
                ////string, boolean, int, DateTime, boolean, int, DateTime, int
            }
        }