trunk/GBPVRProgramDatabaseFixer/Program.cs

#define OVERRIDE_COMMANDLINE_ARGUMENTS // when defined will override supplied commandline args
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Enterprise.Logging;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;
using libxmltv.Core;
using libxmltv.Interfaces;
using libxmltv;
namespace GBPVRProgramDatabaseFixer
{
    class Program
    {
        static ISQLLITE sqlite;
        static string XMLTV_FILE = "";
        static string GBPVR_DATABASE = "";

        static bool LOADING_XMLTV_FILE = false;
        static bool XMLTV_INSTANCE_CREATED = false;
        static int LAST_REPORTED_XMLTV_PROGRESS = 0;


        static bool LOADING_GBPVR_DATABASE = false;
        static bool SQLLIST_INSTANCE_CREATED = false;
        static int LAST_REPORTED_SQLLITE_PROGRESS = 0;

        static FileInfo fi_XMLTVFILE;
        static FileInfo fi_GBPVRDATABASE;
        static void CreateLog()
        {
            string log_path = Application.StartupPath;
            string log_filename = string.Format("{0}.log", typeof(Program).Assembly.GetName().Name);
            gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All);
#if DEBUG
            LogLevel gLevel = gLog.LogLevel;
            gLevel |= LogLevel.kLogLevel_VerboseDebug;
            gLevel |= LogLevel.kLogLevel_Debug;
            gLog.SetLogLevel(gLevel);
#else
            LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
            // it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
            gLevel &= ~LogLevel.kLogLevel_Debug; // ensure this is not set, ever in release mode         
            gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode         
            gLog.SetLogLevel(gLevel);
#endif
            gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
        }

        [Conditional("OVERRIDE_COMMANDLINE_ARGUMENTS")]
        static void CreateDebugCommandlineArgs(ref List<string> cargs)
        {
           cargs = new List<string>();
            cargs.Add(string.Format("--xmltv_file=\"{0}\"", @"c:\EPG Guide\Guide\tvguide.xml"));
            cargs.Add(string.Format("--gbprv_db=\"{0}\"", @"c:\Program Files (x86)\Devnz\GBPVR\gbpvr.db3"));
        }

        static List<string> CreateCommandlineArgs(string[] args)
        {
            List<string> cargs = new List<string>(args);
            CreateDebugCommandlineArgs(ref cargs);
            return cargs;
        }

        static void Main(string[] args)
        {
            CreateLog();
            var cargs = CreateCommandlineArgs(args);
            foreach (var carg in cargs)
            {
                if (carg.ToLower().Contains("--xmltv_file="))
                {
                    XMLTV_FILE = carg.Replace("--xmltv_file=", "").Replace("\"","");
                    gLog.Info.WriteLine("XMLTV FILE: '{0}'", XMLTV_FILE);
                }
                else if (carg.ToLower().Contains("--gbprv_db="))
                {
                    GBPVR_DATABASE = carg.Replace("--gbprv_db=", "").Replace("\"", "");
                    gLog.Info.WriteLine("GBPVR DATABASE: '{0}'", GBPVR_DATABASE);
                }
                else
                {
                    gLog.Warn.WriteLine("Unknown commandline option: {0}", carg);
                }
            }

            LoadXMLTVFile();
            LoadGBPVRDatabase();
            PerformDatabaseProcessing();
        }

        static void ConsoleOverwritePreviosLine(string format, params object[] args)
        {
            Console.WriteLine(format,args);
            Console.SetCursorPosition(0, Console.CursorTop - 1);
        }

        static void gLog_ReportProgress(object sender, ReportProgressEventArgs e) 
        {
            if (!XMLTV_INSTANCE_CREATED && LOADING_XMLTV_FILE)
            {
                if (LAST_REPORTED_XMLTV_PROGRESS != e.Progress)
                {
                    ConsoleOverwritePreviosLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
                    LAST_REPORTED_XMLTV_PROGRESS = e.Progress;
                    if (e.Progress == 100)
                    {
                        Console.WriteLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
                    }
                }
            }
            if (!SQLLIST_INSTANCE_CREATED && LOADING_GBPVR_DATABASE)
            {
                if (LAST_REPORTED_SQLLITE_PROGRESS != e.Progress)
                {
                    ConsoleOverwritePreviosLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
                    LAST_REPORTED_SQLLITE_PROGRESS = e.Progress;
                    if (e.Progress == 100)
                    {
                        Console.WriteLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
                    }
                }
            }
        }
        static void LoadXMLTVFile()
        {
            LOADING_XMLTV_FILE = true;
            if (string.IsNullOrEmpty(XMLTV_FILE))
            {
                gLog.Error.WriteLine("XMLTV File is either a null or empty string.");
                LOADING_XMLTV_FILE = false;
                return;
            }
            fi_XMLTVFILE = new FileInfo(XMLTV_FILE);
            if (!fi_XMLTVFILE.Exists)
            {
                gLog.Error.WriteLine("Could not find XMLTV File: {0}", fi_XMLTVFILE.FullName);
                LOADING_XMLTV_FILE = false;
                return;
            }

            XMLTV.Create(fi_XMLTVFILE.FullName, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
            while (!XMLTV_INSTANCE_CREATED) { Application.DoEvents(); }
            LOADING_XMLTV_FILE = false;
        }
        static void XMLTV_OnInstanceCreated(object sender, EventArgs e) { XMLTV_INSTANCE_CREATED = true; }

        static void LoadGBPVRDatabase()
        {
            LOADING_GBPVR_DATABASE = true;
            if (string.IsNullOrEmpty(GBPVR_DATABASE))
            {
                gLog.Error.WriteLine("GBPVR Datbase is either a null or empty string.");
                LOADING_GBPVR_DATABASE = false;
                return;
            }
            fi_GBPVRDATABASE = new FileInfo(GBPVR_DATABASE);
            if (!fi_GBPVRDATABASE.Exists)
            {
                gLog.Error.WriteLine("Could not find GBPVR Database: {0}", fi_GBPVRDATABASE.FullName);
                LOADING_GBPVR_DATABASE = false;
                return;
            }
            sqlite = SQLLITE.Create(fi_GBPVRDATABASE.FullName, new EventHandler<EventArgs>(SQLLITE_OnInstanceCreated));
            while (!SQLLIST_INSTANCE_CREATED) { Application.DoEvents(); }
            LOADING_GBPVR_DATABASE = false;
        }
        static void SQLLITE_OnInstanceCreated(object sender, EventArgs e) { SQLLIST_INSTANCE_CREATED = true; }


        static List<SQLLITE.IPROGRAMME> gbpvr_programs;
        static List<SQLLITE.ICHANNEL> gbpvr_channels;
        static List<SQLLITE.IRECORDING_SCHEDULE> gbpvr_recordings;
        static List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs;
        static void PerformDatabaseProcessing()
        {
            gbpvr_channels = sqlite.Channels;
            gbpvr_programs = sqlite.Programs;
            gbpvr_recordings = sqlite.Recordings;            
            Type datatype;
            var xmlt_raw_program_data = (IProgramDefinitionList)XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out datatype);
            //xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => p.ChannelNumber).ThenBy(p => DateTime.Parse(p.Start)).ToList();
            //xmltv_programs = xmltv_programs.FindAll(p => p.Title == "Law & Order: Criminal Intent").ToList();
            xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => DateTime.Parse(p.Start)).ToList();


            var gbpvr_programs_startdate_range = sqlite.GetProgramsDateRange(gbpvr_programs);
            var xmltv_programs_startdate_range = GetXMLTVProgramStartDateRange(xmltv_programs);
            gbpvr_programs = sqlite.FilterProgramsByDateRange(gbpvr_programs, xmltv_programs_startdate_range);
            xmltv_programs = xmltv_programs.OrderBy(s => s.ChannelNumber).ThenBy(s => DateTime.Parse(s.Start)).ToList();
            CheckScheduledRecordingsForDiscrepancies();
            CheckProgramsForDiscrepancies();
        }

        static IDateTimeRange GetXMLTVProgramStartDateRange(List<libxmltv.Interfaces.IProgramDefinition> programs)
        {
            IDateTimeRange range = DateTimeRange.Create();
            var list = new List<libxmltv.Interfaces.IProgramDefinition>(programs.ToArray());
            DateTime first = new DateTime();
            DateTime last = new DateTime();
            first = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().First().Start);
            last = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().Last().Start);
            gLog.Info.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
            gLog.Info.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
            range = DateTimeRange.Create(first, last);
            return range;
        }

        static void CheckScheduledRecordingsForDiscrepancies()
        {
            //gLog.Warn.WriteLine("CheckScheduledRecordingsForDiscrepancies() has not been implemented");
            var manual_gbpvr_recordings = gbpvr_recordings.FindAll(p => p.recording_type == 0).ToList();

            foreach (var manual_recording in manual_gbpvr_recordings)
            {
                string title = manual_recording.filename;
                DateTime start = manual_recording.manual_start_time;
                DateTime end = manual_recording.manual_end_time;

                long channel_oid = manual_recording.manual_channel_oid;

                var found_channel = gbpvr_channels.Find(p => p.oid == channel_oid);
                var channel_number = found_channel.channel_number;

                var found_program = xmltv_programs.ToList().Find(p => 
                    p.Title.ToLower() == title.ToLower() && 
                    p.Start == start.ToDateTimeString() &&
                    p.Stop == end.ToDateTimeString() &&
                    p.ChannelNumber == channel_number
                    );

                if (found_program != null)
                {
                    gLog.Info.WriteLine("Recording might be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
                }
                else
                {
                    gLog.Warn.WriteLine("Recording may not be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());

                    // find the program on the channel at the start time
                    var correct_program = xmltv_programs.ToList().Find(p => 
                        p.ChannelNumber == channel_number &&
                        p.Start == start.ToDateTimeString()
                        );
                    if (correct_program != null)
                    {
                        gLog.Warn.WriteLine("\tThis will be recorded: {0}", correct_program.ToString());
                    }
                }
            }
        }

        static void CheckProgramsForDiscrepancies()
        {
            gLog.Warn.WriteLine("CheckProgramsForDiscrepancies() has not been implemented");
        }
    }
}
1	william	154	#define OVERRIDE_COMMANDLINE_ARGUMENTS // when defined will override supplied commandline args
2	william	153	using System;
3	william	150	using System.Collections.Generic;
4			using System.Text;
5	william	159	using System.Linq;
6	william	153	using Enterprise.Logging;
7			using System.Windows.Forms;
8			using System.Diagnostics;
9			using System.IO;
10			using libxmltv.Core;
11	william	159	using libxmltv.Interfaces;
12			using libxmltv;
13	william	150	namespace GBPVRProgramDatabaseFixer
14			{
15			class Program
16			{
17	william	163	static ISQLLITE sqlite;
18	william	153	static string XMLTV_FILE = "";
19			static string GBPVR_DATABASE = "";
20	william	155
21			static bool LOADING_XMLTV_FILE = false;
22	william	153	static bool XMLTV_INSTANCE_CREATED = false;
23	william	155	static int LAST_REPORTED_XMLTV_PROGRESS = 0;
24	william	153
25
26	william	155	static bool LOADING_GBPVR_DATABASE = false;
27			static bool SQLLIST_INSTANCE_CREATED = false;
28			static int LAST_REPORTED_SQLLITE_PROGRESS = 0;
29
30	william	153	static FileInfo fi_XMLTVFILE;
31	william	155	static FileInfo fi_GBPVRDATABASE;
32	william	153	static void CreateLog()
33			{
34			string log_path = Application.StartupPath;
35			string log_filename = string.Format("{0}.log", typeof(Program).Assembly.GetName().Name);
36			gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All);
37			#if DEBUG
38			LogLevel gLevel = gLog.LogLevel;
39			gLevel \|= LogLevel.kLogLevel_VerboseDebug;
40			gLevel \|= LogLevel.kLogLevel_Debug;
41			gLog.SetLogLevel(gLevel);
42			#else
43			LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
44			// it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
45			gLevel &= ~LogLevel.kLogLevel_Debug; // ensure this is not set, ever in release mode
46			gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode
47			gLog.SetLogLevel(gLevel);
48			#endif
49			gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
50			}
51
52	william	154	[Conditional("OVERRIDE_COMMANDLINE_ARGUMENTS")]
53	william	153	static void CreateDebugCommandlineArgs(ref List<string> cargs)
54			{
55			cargs = new List<string>();
56			cargs.Add(string.Format("--xmltv_file=\"{0}\"", @"c:\EPG Guide\Guide\tvguide.xml"));
57			cargs.Add(string.Format("--gbprv_db=\"{0}\"", @"c:\Program Files (x86)\Devnz\GBPVR\gbpvr.db3"));
58			}
59
60			static List<string> CreateCommandlineArgs(string[] args)
61			{
62			List<string> cargs = new List<string>(args);
63			CreateDebugCommandlineArgs(ref cargs);
64			return cargs;
65			}
66
67	william	150	static void Main(string[] args)
68			{
69	william	153	CreateLog();
70			var cargs = CreateCommandlineArgs(args);
71			foreach (var carg in cargs)
72			{
73			if (carg.ToLower().Contains("--xmltv_file="))
74			{
75			XMLTV_FILE = carg.Replace("--xmltv_file=", "").Replace("\"","");
76			gLog.Info.WriteLine("XMLTV FILE: '{0}'", XMLTV_FILE);
77			}
78			else if (carg.ToLower().Contains("--gbprv_db="))
79			{
80			GBPVR_DATABASE = carg.Replace("--gbprv_db=", "").Replace("\"", "");
81			gLog.Info.WriteLine("GBPVR DATABASE: '{0}'", GBPVR_DATABASE);
82			}
83			else
84			{
85			gLog.Warn.WriteLine("Unknown commandline option: {0}", carg);
86			}
87			}
88
89	william	157	LoadXMLTVFile();
90	william	155	LoadGBPVRDatabase();
91	william	163	PerformDatabaseProcessing();
92	william	150	}
93	william	153
94	william	155	static void ConsoleOverwritePreviosLine(string format, params object[] args)
95			{
96			Console.WriteLine(format,args);
97			Console.SetCursorPosition(0, Console.CursorTop - 1);
98			}
99
100	william	153	static void gLog_ReportProgress(object sender, ReportProgressEventArgs e)
101			{
102	william	155	if (!XMLTV_INSTANCE_CREATED && LOADING_XMLTV_FILE)
103	william	153	{
104	william	155	if (LAST_REPORTED_XMLTV_PROGRESS != e.Progress)
105			{
106			ConsoleOverwritePreviosLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
107			LAST_REPORTED_XMLTV_PROGRESS = e.Progress;
108			if (e.Progress == 100)
109			{
110			Console.WriteLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
111			}
112			}
113	william	153	}
114	william	155	if (!SQLLIST_INSTANCE_CREATED && LOADING_GBPVR_DATABASE)
115			{
116			if (LAST_REPORTED_SQLLITE_PROGRESS != e.Progress)
117			{
118			ConsoleOverwritePreviosLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
119			LAST_REPORTED_SQLLITE_PROGRESS = e.Progress;
120			if (e.Progress == 100)
121			{
122			Console.WriteLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
123			}
124			}
125			}
126	william	153	}
127			static void LoadXMLTVFile()
128			{
129	william	155	LOADING_XMLTV_FILE = true;
130	william	153	if (string.IsNullOrEmpty(XMLTV_FILE))
131			{
132			gLog.Error.WriteLine("XMLTV File is either a null or empty string.");
133	william	155	LOADING_XMLTV_FILE = false;
134	william	153	return;
135			}
136			fi_XMLTVFILE = new FileInfo(XMLTV_FILE);
137			if (!fi_XMLTVFILE.Exists)
138			{
139			gLog.Error.WriteLine("Could not find XMLTV File: {0}", fi_XMLTVFILE.FullName);
140	william	155	LOADING_XMLTV_FILE = false;
141	william	153	return;
142			}
143
144			XMLTV.Create(fi_XMLTVFILE.FullName, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
145			while (!XMLTV_INSTANCE_CREATED) { Application.DoEvents(); }
146	william	155	LOADING_XMLTV_FILE = false;
147	william	153	}
148	william	155	static void XMLTV_OnInstanceCreated(object sender, EventArgs e) { XMLTV_INSTANCE_CREATED = true; }
149	william	153
150	william	155	static void LoadGBPVRDatabase()
151			{
152			LOADING_GBPVR_DATABASE = true;
153			if (string.IsNullOrEmpty(GBPVR_DATABASE))
154			{
155			gLog.Error.WriteLine("GBPVR Datbase is either a null or empty string.");
156			LOADING_GBPVR_DATABASE = false;
157			return;
158			}
159			fi_GBPVRDATABASE = new FileInfo(GBPVR_DATABASE);
160			if (!fi_GBPVRDATABASE.Exists)
161			{
162			gLog.Error.WriteLine("Could not find GBPVR Database: {0}", fi_GBPVRDATABASE.FullName);
163			LOADING_GBPVR_DATABASE = false;
164			return;
165			}
166	william	163	sqlite = SQLLITE.Create(fi_GBPVRDATABASE.FullName, new EventHandler<EventArgs>(SQLLITE_OnInstanceCreated));
167	william	156	while (!SQLLIST_INSTANCE_CREATED) { Application.DoEvents(); }
168	william	155	LOADING_GBPVR_DATABASE = false;
169			}
170	william	156	static void SQLLITE_OnInstanceCreated(object sender, EventArgs e) { SQLLIST_INSTANCE_CREATED = true; }
171	william	157
172
173	william	158	static List<SQLLITE.IPROGRAMME> gbpvr_programs;
174	william	159	static List<SQLLITE.ICHANNEL> gbpvr_channels;
175	william	158	static List<SQLLITE.IRECORDING_SCHEDULE> gbpvr_recordings;
176	william	162	static List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs;
177	william	157	static void PerformDatabaseProcessing()
178			{
179	william	159	gbpvr_channels = sqlite.Channels;
180	william	158	gbpvr_programs = sqlite.Programs;
181	william	159	gbpvr_recordings = sqlite.Recordings;
182			Type datatype;
183	william	162	var xmlt_raw_program_data = (IProgramDefinitionList)XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out datatype);
184	william	163	//xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => p.ChannelNumber).ThenBy(p => DateTime.Parse(p.Start)).ToList();
185			//xmltv_programs = xmltv_programs.FindAll(p => p.Title == "Law & Order: Criminal Intent").ToList();
186			xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => DateTime.Parse(p.Start)).ToList();
187	william	162
188
189	william	163	var gbpvr_programs_startdate_range = sqlite.GetProgramsDateRange(gbpvr_programs);
190			var xmltv_programs_startdate_range = GetXMLTVProgramStartDateRange(xmltv_programs);
191			gbpvr_programs = sqlite.FilterProgramsByDateRange(gbpvr_programs, xmltv_programs_startdate_range);
192			xmltv_programs = xmltv_programs.OrderBy(s => s.ChannelNumber).ThenBy(s => DateTime.Parse(s.Start)).ToList();
193	william	158	CheckScheduledRecordingsForDiscrepancies();
194			CheckProgramsForDiscrepancies();
195	william	157	}
196	william	158
197	william	163	static IDateTimeRange GetXMLTVProgramStartDateRange(List<libxmltv.Interfaces.IProgramDefinition> programs)
198			{
199			IDateTimeRange range = DateTimeRange.Create();
200			var list = new List<libxmltv.Interfaces.IProgramDefinition>(programs.ToArray());
201			DateTime first = new DateTime();
202			DateTime last = new DateTime();
203			first = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().First().Start);
204			last = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().Last().Start);
205			gLog.Info.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
206			gLog.Info.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
207			range = DateTimeRange.Create(first, last);
208			return range;
209			}
210
211	william	158	static void CheckScheduledRecordingsForDiscrepancies()
212			{
213	william	159	//gLog.Warn.WriteLine("CheckScheduledRecordingsForDiscrepancies() has not been implemented");
214			var manual_gbpvr_recordings = gbpvr_recordings.FindAll(p => p.recording_type == 0).ToList();
215
216			foreach (var manual_recording in manual_gbpvr_recordings)
217			{
218			string title = manual_recording.filename;
219			DateTime start = manual_recording.manual_start_time;
220			DateTime end = manual_recording.manual_end_time;
221
222	william	160	long channel_oid = manual_recording.manual_channel_oid;
223
224			var found_channel = gbpvr_channels.Find(p => p.oid == channel_oid);
225			var channel_number = found_channel.channel_number;
226
227	william	159	var found_program = xmltv_programs.ToList().Find(p =>
228			p.Title.ToLower() == title.ToLower() &&
229			p.Start == start.ToDateTimeString() &&
230	william	160	p.Stop == end.ToDateTimeString() &&
231			p.ChannelNumber == channel_number
232	william	159	);
233
234			if (found_program != null)
235			{
236			gLog.Info.WriteLine("Recording might be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
237			}
238			else
239			{
240			gLog.Warn.WriteLine("Recording may not be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
241	william	161
242			// find the program on the channel at the start time
243			var correct_program = xmltv_programs.ToList().Find(p =>
244			p.ChannelNumber == channel_number &&
245			p.Start == start.ToDateTimeString()
246			);
247			if (correct_program != null)
248			{
249			gLog.Warn.WriteLine("\tThis will be recorded: {0}", correct_program.ToString());
250			}
251	william	159	}
252			}
253	william	158	}
254	william	159
255	william	158	static void CheckProgramsForDiscrepancies()
256			{
257			gLog.Warn.WriteLine("CheckProgramsForDiscrepancies() has not been implemented");
258			}
259	william	150	}
260			}