친구의 프로그램에 사용한 내용이다.

0시~9시까지 <시간외근무>, 9시~18시까지 < 시간내근무(점심 12시~13시제외) >, 18시~24시 <시간외근무>

18시 이후에 저녁식사시간을 체크해야함. 18시가 될수도 있고 19시가 될수도... 또 30분동안먹을수도 있고 1시간을 먹을수도 있고.

그시간을 계산해서 각각 포인트 및 메모를 한다.

근무시간을 이리 저리 바꿔가며 테스트함. 저녁시간도 이리 저리 바꾸며 테스트

- 09:00 ~ 18:00

- 07:00 ~ 10:00

- 11:00 ~ 14:00

- 15:00 ~ 19:00 ( 저녁 먹은날, 안먹은날 )

- 08:00 ~ 20:00 ( 저녁 먹은날, 안먹은날 )

- 16:00 ~ 19:30 ( 저녁 먹은날 18:30분 부터 1시간 or 30분, 저녁안먹은날 )

# 테스트를 위한 시간설정 {

- 09:00 ~ 12:30 ( 점심시간 12시부터이므로 30분을 빼버림 ㅡ.ㅡ;; 밥은 꼭 12시에 먹어야 한다! )

- 11:30 ~ 13:00

- 12:00 ~ 12:30

- 12:30 ~ 13:00

# 테스트를 위한 시간설정 }

기타 시간을 바꿔가면서 테스트 했음.

점심시간에 대해 무조건 12시 ~ 13시 한시간으로 처리하다보니...

12시부터 13시는 무조건 제외하도록 만들었다.

* Method내에 있는 memo는 여기서 사용하지 않음. 다른곳 Method를 복사해와서 그냥 두었다.

    private decimal Calc(string gubun)
        {
            // todo: 9to6 에 맞춰 8hour 이후 시간은 OT로 잡는다.
            decimal sumWT_Value = 0m;
            decimal sumOT_Value = 0m;

            Dictionary<string, decimal> TimeTables = new Dictionary<string, decimal>() {
                {"", 0.0m},
                {"00:00",  0.0m}, {"00:30",  0.5m},
                {"01:00",  1.0m}, {"01:30",  1.5m},
                {"02:00",  2.0m}, {"02:30",  2.5m},
                {"03:00",  3.0m}, {"03:30",  3.5m},
                {"04:00",  4.0m}, {"04:30",  4.5m},
                {"05:00",  5.0m}, {"05:30",  5.5m},
                {"06:00",  6.0m}, {"06:30",  6.5m},
                {"07:00",  7.0m}, {"07:30",  7.5m},
                {"08:00",  8.0m}, {"08:30",  8.5m},
                {"09:00",  9.0m}, {"09:30",  9.5m},
                {"10:00", 10.0m}, {"10:30", 10.5m},
                {"11:00", 11.0m}, {"11:30", 11.5m},
                {"12:00", 12.0m}, {"12:30", 12.5m},
                {"13:00", 13.0m}, {"13:30", 13.5m},
                {"14:00", 14.0m}, {"14:30", 14.5m},
                {"15:00", 15.0m}, {"15:30", 15.5m},
                {"16:00", 16.0m}, {"16:30", 16.5m},
                {"17:00", 17.0m}, {"17:30", 17.5m},
                {"18:00", 18.0m}, {"18:30", 18.5m},
                {"19:00", 19.0m}, {"19:30", 19.5m},
                {"20:00", 20.0m}, {"20:30", 20.5m},
                {"21:00", 21.0m}, {"21:30", 21.5m},
                {"22:00", 22.0m}, {"22:30", 22.5m},
                {"23:00", 23.0m}, {"23:30", 23.5m},
                {"24:00", 24.0m}
            };

            string fromTime = From;  // 근무시작시간
            string toTime = To;         // 근무종료시간
            
            string fromdinner = ("" + FromDinner).Trim(), todinner = ""; //  밥먹기 시작시간, 종료시간.( toDinner는 소스에서 구한다 )

            string hourMinute = ( "" + DinnerHourMinute).Trim();          // 밥먹는 시간 H: 1시간, M: 30분
            
            var getAfterTime = new Func<string, string, string>((fdTime, HM) =>
            {

                // todo : 밥먹는 시간 구함,  todinner 구할때 쓴다.

                string afterTime = "";
                DateTime tmpTime;
                if (DateTime.TryParseExact(DateTime.Today.ToShortDateString() + " " + fdTime, "yyyy-MM-dd HH:mm", null, System.Globalization.DateTimeStyles.AssumeLocal, out tmpTime))
                {
                    if (HM == "H")
                    {
                        afterTime = tmpTime.AddHours(1).ToString("HH:mm");
                    }
                    else
                    {
                        afterTime = tmpTime.AddMinutes(30).ToString("HH:mm");
                    }
                }
                return afterTime;
            });

            decimal val1 = TimeTables[fromTime];
            decimal val2 = TimeTables[toTime];
            decimal val = val2 - val1;

            string memo = "";

            string _from = fromTime;
            string _to = toTime;

            if ("09:00".CompareTo(toTime) <= 0 && fromTime.CompareTo("09:00") < 0)
            {
                // 아침 OT 계산!
                val1 = TimeTables[fromTime];
                val2 = TimeTables["09:00"];
                val = val2 - val1;
                _from = fromTime;
                _to = "09:00";
                sumOT_Value += val;
                memo += string.Format("{0}~{1} > {2}", _from, _to, val);
                memo += Environment.NewLine;
            }

            if ("09:00".CompareTo(toTime) <= 0)
            {
                if ("09:00".CompareTo(fromTime) < 0)
                {
                    val1 = TimeTables[fromTime];
                    _from = fromTime;
                }
                else
                {

                    val1 = TimeTables["09:00"];
                    _from = "09:00";
                }

                if ("18:00".CompareTo(toTime) <= 0)
                {
                    val2 = TimeTables["18:00"];
                    _to = "18:00";
                }
                else
                {
                    val2 = TimeTables[toTime];
                    _to = toTime;
                }

                val = val2 - val1;

                decimal offset1 = 0m;
                decimal offset2 = 0m;

                if (_from.CompareTo("12:00") <= 0 && "12:30".CompareTo(_to) <= 0)
                {
                    offset1 = TimeTables["12:00"];
                }
                else if (_from.CompareTo("12:30") <= 0 && "12:30".CompareTo(_to) <= 0)
                {
                    offset1 = TimeTables["12:30"];
                }
                if ("13:00".CompareTo(_to) <= 0 && _from.CompareTo("12:30") <= 0)
                {
                    offset2 = TimeTables["13:00"];
                }
                else if ("12:30".CompareTo(_to) <= 0 && _from.CompareTo("12:30") <= 0)
                {
                    offset2 = TimeTables["12:30"];
                }
                val = val - (offset2 - offset1);

                sumWT_Value += val;
                memo += string.Format("{0}~{1} > {2}", _from, _to, val);
                memo += Environment.NewLine;
            }

            // 오후 OT
            if ("18:00".CompareTo(toTime) <= 0)
            {
                if (string.IsNullOrEmpty(fromdinner.Trim()) == false)
                {
                    if ("18:00".CompareTo(fromdinner) >= 0)
                    {
                        // 식사시간이 18시면
                        todinner = getAfterTime(fromdinner, hourMinute);
                        if (todinner.CompareTo(_to) < 0)
                        {
                            val1 = TimeTables[fromdinner];
                            val2 = TimeTables[todinner];

                            _from = fromdinner;
                            _to = todinner;
                            val = val2 - val1;
                            if (val > 0)
                            {
                                memo += string.Format("{0}~{1} <밥> {2}", _from, _to, val);
                                memo += Environment.NewLine;
                            }
                        }
                    }
                    else
                    {
                        if (fromdinner.CompareTo(_to) < 0)
                        {
                            // 식사시간이 18시가 지나서 18시 30분이라면...
                            //# 밥먹기 전까지 일한 시간
                            val1 = TimeTables["18:00"];
                            val2 = TimeTables[fromdinner];
                            _from = "18:00";
                            _to = fromdinner;
                            val = val2 - val1;
                            memo += string.Format("{0}~{1} > {2}", _from, _to, val);
                            memo += Environment.NewLine;
                            // 밥먹은시간..
                            todinner = getAfterTime(fromdinner, hourMinute);
                            if (todinner.CompareTo(_to) < 0)
                            {
                                val1 = TimeTables[fromdinner];
                                val2 = TimeTables[todinner];

                                _from = fromdinner;
                                _to = todinner;
                                val = val2 - val1;
                                if (val > 0)
                                {
                                    memo += string.Format("{0}~{1} <밥> {2}", _from, _to, val);
                                    memo += Environment.NewLine;
                                }
                            }
                        }
                    }

                    if (todinner.CompareTo(toTime) < 0)
                    {
                        if (fromdinner.CompareTo(toTime) < 0)
                        {
                            todinner = getAfterTime(fromdinner, hourMinute);

                            val1 = TimeTables[todinner];
                            val2 = TimeTables[toTime];
                            _from = todinner;
                            _to = toTime;
                            val = val2 - val1;
                            if (val > 0)
                            {
                                sumOT_Value += val;
                                memo += string.Format("{0}~{1} > {2}", _from, _to, val);
                                memo += Environment.NewLine;
                            }
                        }
                    }
                }
                else
                {
                    if (todinner.CompareTo(_to) < 0)
                    {
                        // 저녁식사 X
                        val1 = TimeTables["18:00"];
                        val2 = TimeTables[toTime];
                        _from = "18:00";
                        _to = toTime;
                        val = val2 - val1;
                        if (val > 0)
                        {
                            sumOT_Value += val;
                            memo += string.Format("{0}~{1} > {2}", _from, _to, val);
                            memo += Environment.NewLine;
                        }
                    }
                }
            }

            if (gubun == "Total")
            {
                return sumOT_Value + sumWT_Value;
            }
            else
            {
                return sumOT_Value;
            }
        }