61fcda6377c3941f33130902c15ba27e

I'd like to build up something to cover many relative date formats

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
    class RelativeDateParser
    {
        
        public static DateTime Parse(string input)
        {
            DateTime dt = DateTime.Now;

            // parse "x days x hours x minutes x seconds" or "x days x hours x minutes x seconds ago"
            Regex r = new Regex("(day)|(hour)|(minues)|(second)");
            if (r.Match(input).Success == true)
            {
                dt = ParseDHMS(input);
            }

            // parse "yesterday" or "today" or "tomorrow" or "eow" or "eod"
            r = new Regex("(today)|(tomorrow)|(eow)|(eod)");
            if (r.Match(input).Success == true)
            {
                dt = ParseGenericRelative(input);
            }

            Console.WriteLine("Now DateTime: " + DateTime.Now.ToString());
            Console.WriteLine("New DateTime: " + dt.ToString());
            return dt;
        }

        private static DateTime ParseGenericRelative(string input)
        {
            throw new NotImplementedException("Not implemented");
        }

        private static DateTime ParseDHMS(string input)
        {
            DateTime dt;
            double days = 0;
            double hours = 0;
            double minutes = 0;
            double seconds = 0;
            
            // search for days
            Regex r = new Regex(@"(\d+)\s*day");
            Match m = r.Match(input);
            if (m.Success == true)
            {
                string match = m.Groups[1].Value;
                days += Double.Parse(match);
            }

            // search for hours
            r = new Regex(@"(\d+)\s*hour");
            m = r.Match(input);
            if (m.Success == true)
            {
                string match = m.Groups[1].Value;
                hours += Double.Parse(match);
            }

            // search for minutes
            r = new Regex(@"(\d+)\s*minute");
            m = r.Match(input);
            if (m.Success == true)
            {
                string match = m.Groups[1].Value;
                minutes += Double.Parse(match);
            }

            // search for seconds
            r = new Regex(@"(\d+)\s*second");
            m = r.Match(input);
            if (m.Success == true)
            {
                string match = m.Groups[1].Value;
                seconds += Double.Parse(match);
            }

            // In past?
            r = new Regex(@"ago");
            m = r.Match(input);
            if (m.Success == true)
            {
                days = days * -1;
                hours = hours * -1;
                minutes = minutes * -1;
                seconds = seconds * -1;
            }

            /////////////////////
            // Add offsets to now
            dt = DateTime.Now.AddDays(days).AddHours(hours).AddMinutes(minutes).AddSeconds(seconds);

            return dt;
        }
    }

Refactorings

No refactoring yet !

4d72203c38dd5f3e3d2d446b5888e8a7

Elij

September 11, 2008, September 11, 2008 06:16, permalink

1 rating. Login to rate!

Please note I haven't tested/tried to build this -- same logic but with a bit of reuse

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
using System;
using System.Text.RegularExpressions;

class RelativeDateParser
    {
        
        public static DateTime Parse(string input)
        {
            DateTime dt = DateTime.Now;

            // parse "x days x hours x minutes x seconds" or "x days x hours x minutes x seconds ago"
            Regex r = new Regex("(day)|(hour)|(minues)|(second)");
            if (r.Match(input).Success == true)
            {
                dt = ParseDHMS(input, dt);
            }

            // parse "yesterday" or "today" or "tomorrow" or "eow" or "eod"
            r = new Regex("(today)|(tomorrow)|(eow)|(eod)");
            if (r.Match(input).Success == true)
            {
                dt = ParseGenericRelative(input);
            }

            Console.WriteLine("Now DateTime: " + DateTime.Now.ToString());
            Console.WriteLine("New DateTime: " + dt.ToString());
            return dt;
        }

        private static DateTime ParseGenericRelative(string input)
        {
            throw new NotImplementedException("Not implemented");
        }
        
        private static DateTime ParseDHMS(string input, DateTime seedDtm)
        {
            TimeSpan timeSpan = new TimeSpan(0);
            
            // search for days
            timeSpan += TimeSpan.FromDays(getMetricValue(input, "day"));
            // search for hours
            timeSpan += TimeSpan.FromHours(getMetricValue(input, "hour"));
            // search for minutes
            timeSpan += TimeSpan.FromMinutes(getMetricValue(input, "minutes"));
            // search for seconds
            timeSpan += TimeSpan.FromSeconds(getMetricValue(input, "second"));
            
            return seedDtm.AddTicks(timeSpan.Ticks * (int)(input.EndsWith("ago") ? -1 : 1));
        }
        
        private static double getMetricValue(string input, string metric)
        {
            Regex r = new Regex(@"(\d+)\s*" + metric);
            Match m = r.Match(input);
            if (m.Success)
            {
                string match = m.Groups[1].Value;
                return Double.Parse(match);
            }
            
            return 0;
        }
    }

Your refactoring





Format Copy from initial code

or Cancel