/[xmltv_parser]/trunk/GBPVRProgramDatabaseFixer/SQLLITE.cs
ViewVC logotype

Diff of /trunk/GBPVRProgramDatabaseFixer/SQLLITE.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 157 by william, Thu Mar 14 19:36:01 2013 UTC revision 195 by william, Sat Mar 16 21:44:30 2013 UTC
# Line 6  using System.Text; Line 6  using System.Text;
6  using System.Data.SQLite;  using System.Data.SQLite;
7  using System.Diagnostics;  using System.Diagnostics;
8  using Enterprise.Logging;  using Enterprise.Logging;
9    using libxmltv;
10    using libxmltv.Interfaces;
11    using libxmltv.Core;
12  namespace GBPVRProgramDatabaseFixer  namespace GBPVRProgramDatabaseFixer
13  {  {
14      internal class SQLLITE      public interface IOldNewProgram
15        {
16            SQLLITE.IPROGRAMME OldProgram { get; }
17            SQLLITE.IPROGRAMME NewProgram { get; }
18        }
19        public interface ISQLLITE
20        {
21            List<SQLLITE.IPROGRAMME> Programs { get; }
22            List<SQLLITE.IRECORDING_SCHEDULE> Recordings { get; }
23            List<SQLLITE.ICHANNEL> Channels { get; }
24            IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs);
25            List<IOldNewProgram> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> removed_programs);
26    
27            void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs);
28            void UpdateGBPVRPrograms(List<IOldNewProgram> programs);
29    
30        }
31        public class SQLLITE : ISQLLITE
32      {      {
33            private class OldNewProgram : IOldNewProgram
34            {
35                public OldNewProgram() : this(new PROGRAMME(), new PROGRAMME()) { }
36                public OldNewProgram(IPROGRAMME _old, IPROGRAMME _new) { OldProgram = _old; NewProgram = _new; }
37    
38                public IPROGRAMME OldProgram { get; private set; }
39                public IPROGRAMME NewProgram { get; private set; }
40            }
41            public static ISQLLITE Create(string database, EventHandler<EventArgs> OnInstanceCreated)
42            {
43                return new SQLLITE(database, OnInstanceCreated);
44            }
45    
46          #region DATABASE DEFINITIONS          #region DATABASE DEFINITIONS
47    
48            public interface ICHANNEL
49            {
50                Int64 oid { get; }
51                String name { get; }
52                String channelID { get; }
53                Int64 channel_number { get; }
54                String favourite_channel { get; }
55                String display_name { get; }
56            }
57            private class CHANNEL : ICHANNEL
58            {
59                public CHANNEL()
60                {
61                    BaseDatabaseDefinition<CHANNEL>.CreateDefault(this);
62                }
63                //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }
64    
65                public static void Create(ref CHANNEL instance, SQLiteDataReader r, int index)
66                {
67                    BaseDatabaseDefinition<CHANNEL>.Create(ref instance, r, index);
68                }
69                #region ICHANNEL members
70                public Int64 oid { get; set; }
71                public String name { get; set; }
72                public String channelID { get; set; }
73                public Int64 channel_number { get; set; }
74                public String favourite_channel { get; set; }
75                public String display_name { get; set; }
76                #endregion
77            }
78          public interface IRECORDING_SCHEDULE          public interface IRECORDING_SCHEDULE
79          {          {
80              Int64 oid { get; }              Int64 oid { get; }
# Line 26  namespace GBPVRProgramDatabaseFixer Line 89  namespace GBPVRProgramDatabaseFixer
89              Int64 manual_channel_oid { get; }              Int64 manual_channel_oid { get; }
90              Int64 quality_level { get; }              Int64 quality_level { get; }
91              Int64 pre_pad_minutes { get; }              Int64 pre_pad_minutes { get; }
92              Int64 post_pad_minutes { get;}              Int64 post_pad_minutes { get; }
93              Int32 priority { get; }              Int32 priority { get; }
94              String conversion_profile { get; }              String conversion_profile { get; }
95          }          }
# Line 67  namespace GBPVRProgramDatabaseFixer Line 130  namespace GBPVRProgramDatabaseFixer
130                  }                  }
131              }              }
132              public static void Create(ref T instance, SQLiteDataReader r, int index)              public static void Create(ref T instance, SQLiteDataReader r, int index)
133              {                              {
134                  string field_name = r.GetName(index);                  string field_name = r.GetName(index);
135                  Type field_type = r.GetFieldType(index);                  Type field_type = r.GetFieldType(index);
136                  object field_value = r.GetValue(index);                  object field_value = r.GetValue(index);
# Line 92  namespace GBPVRProgramDatabaseFixer Line 155  namespace GBPVRProgramDatabaseFixer
155                                  {                                  {
156                                      prop.SetValue(instance, field_value, null);                                      prop.SetValue(instance, field_value, null);
157                                  }                                  }
158                                    
159                              }                              }
160                              catch (Exception ex)                              catch (Exception ex)
161                              {                              {
162                                  throw ex;                                  throw ex;
163                              }                              }
# Line 112  namespace GBPVRProgramDatabaseFixer Line 175  namespace GBPVRProgramDatabaseFixer
175    
176          private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE          private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE
177          {          {
178              public RECORDING_SCHEDULE()              public RECORDING_SCHEDULE()
179              {              {
180                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);
181              }              }
182              //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }              //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }
183    
184              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)
185              {              {
186                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);
187              }              }
188    
189              #region IRECORDING_SCHEDULE members              #region IRECORDING_SCHEDULE members
190              public Int64 oid { get; set;}              public Int64 oid { get; set; }
191              public Int64 programme_oid { get; set;}              public Int64 programme_oid { get; set; }
192              public Int64 capture_source_oid { get; set;}              public Int64 capture_source_oid { get; set; }
193              public Int16 status { get; set; }              public Int16 status { get; set; }
194              public String filename { get; set; }              public String filename { get; set; }
195              public Int64 recording_type { get;set; }              public Int64 recording_type { get; set; }
196              public Int64 recording_group { get; set;}              public Int64 recording_group { get; set; }
197              public DateTime manual_start_time { get; set;}              public DateTime manual_start_time { get; set; }
198              public DateTime manual_end_time { get; set; }              public DateTime manual_end_time { get; set; }
199              public Int64 manual_channel_oid { get; set; }              public Int64 manual_channel_oid { get; set; }
200              public Int64 quality_level { get; set; }              public Int64 quality_level { get; set; }
# Line 142  namespace GBPVRProgramDatabaseFixer Line 205  namespace GBPVRProgramDatabaseFixer
205              #endregion              #endregion
206          }          }
207    
208          public interface IPROGRAMME          public interface IPROGRAMME : IEquatable<IPROGRAMME>
209          {          {
210              Int64 oid { get; }              Int64 oid { get; set; }
211              String name { get; }              String name { get; set; }
212              String sub_title { get; }              String sub_title { get; set; }
213              String description { get; }              String description { get; set; }
214              DateTime start_time { get; }              DateTime start_time { get; set; }
215              DateTime end_time { get; }              DateTime end_time { get; set; }
216              Int64 channel_oid { get; }              Int64 channel_oid { get; set; }
217              String unique_identifier { get; }              String unique_identifier { get; set; }
218              String rating { get; }              String rating { get; set; }
219    
220                string ToString();
221                IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite);
222          }          }
223          private class PROGRAMME : IPROGRAMME          private class PROGRAMME : IPROGRAMME
224          {          {
225              public PROGRAMME()              public PROGRAMME()
226              {              {
227                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);
228              }              }
229              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }
230              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)
# Line 175  namespace GBPVRProgramDatabaseFixer Line 241  namespace GBPVRProgramDatabaseFixer
241              public Int64 channel_oid { get; set; }              public Int64 channel_oid { get; set; }
242              public String unique_identifier { get; set; }              public String unique_identifier { get; set; }
243              public String rating { get; set; }              public String rating { get; set; }
244                public IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite)
245                {
246                    ProgramList.ProgramDefintion definition = new ProgramList.ProgramDefintion();
247    
248                    var channel = sqllite.Channels.Find(s => s.oid == this.channel_oid);
249                    var channelname = channel.display_name;
250                    var split = channelname.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
251                    definition.ChannelNumber = Convert.ToInt32(split.First());
252                    definition.ChannelName = string.IsNullOrEmpty(split.Last()) ? string.Empty : split.Last().ToString();
253                    definition.Description = this.description;
254                    definition.Start = this.start_time.ToDateTimeString();
255                    definition.Stop = this.end_time.ToDateTimeString();
256                    definition.SubTitle = this.sub_title;
257                    definition.Title = this.name;
258                    return definition;
259                }
260              #endregion              #endregion
261    
262                public bool Equals(IPROGRAMME other)
263                {
264                    return this.ToString() == other.ToString();
265                }
266                public override string ToString()
267                {
268                    StringBuilder builder = new StringBuilder();
269    
270                    builder.AppendFormat("oid: '{0}' ", oid);
271                    builder.AppendFormat("name: '{0}' ", name);
272                    builder.AppendFormat("sub_title: '{0}' ", sub_title);
273                    builder.AppendFormat("description: '{0}' ", description);
274                    builder.AppendFormat("start_time: '{0}' ", start_time.ToDateTimeString());
275                    builder.AppendFormat("end_time: '{0}' ", end_time.ToDateTimeString());
276                    builder.AppendFormat("channel_oid: '{0}' ", channel_oid);
277                    builder.AppendFormat("unique_identifier: '{0}' ", unique_identifier);
278                    builder.AppendFormat("rating: '{0}'", rating);
279    
280                    return builder.ToString();
281                }
282                public override bool Equals(object obj)
283                {
284                    if (obj == null) { throw new ArgumentNullException("obj", "Object to compare cannot be null"); }
285                    if (obj.GetType().IsAssignableFrom(typeof(IPROGRAMME)))
286                    {
287                        return this.Equals((IPROGRAMME)obj);
288                    }
289                    return base.Equals(obj);
290                }
291                public override int GetHashCode()
292                {
293                    return this.ToString().GetHashCode();
294                }
295          }          }
296          #endregion          #endregion
297          private static class TABLES          private static class TABLES
298          {          {
299              public const string RECORDING_SCHEDULE = "RECORDING_SCHEDULE";              public const string RECORDING_SCHEDULE = "RECORDING_SCHEDULE";
300              public const string PROGRAMME = "PROGRAMME";              public const string PROGRAMME = "PROGRAMME";
301                public const string CHANNEL = "CHANNEL";
302          }          }
303    
304          //public SQLLite() { }          //public SQLLite() { }
305          public SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)          protected SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)
306          {          {
307              this.OnInstanceCreated = OnInstanceCreated;              this.OnInstanceCreated = OnInstanceCreated;
308              //CreateConnection(database);              //CreateConnection(database);
# Line 196  namespace GBPVRProgramDatabaseFixer Line 313  namespace GBPVRProgramDatabaseFixer
313                  return;                  return;
314              }              }
315              ConnectionTest();              ConnectionTest();
316                ReadChannelData();
317              ReadRecodringScheduleData();              ReadRecodringScheduleData();
318              ReadProgrammeData();              ReadProgrammeData();
319              OnCreatedInstance(this, new EventArgs());              OnCreatedInstance(this, new EventArgs());
# Line 204  namespace GBPVRProgramDatabaseFixer Line 322  namespace GBPVRProgramDatabaseFixer
322          [NonSerialized]          [NonSerialized]
323          private EventHandler<EventArgs> _OnInstanceCreated;          private EventHandler<EventArgs> _OnInstanceCreated;
324          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }
325            
326          private void OnCreatedInstance(object sender, EventArgs e)          private void OnCreatedInstance(object sender, EventArgs e)
327          {          {
328              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }
329          }          }
330    
         #region SQLLite  
331          private string Database;          private string Database;
332            #region ISQLLITE members
333          public List<IPROGRAMME> Programs { get; private set; }          public List<IPROGRAMME> Programs { get; private set; }
334          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }
335            public List<ICHANNEL> Channels { get; private set; }
336    
337            public IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs)
338            {
339                var list = new List<IPROGRAMME>(programs.ToArray());
340                DateTime first = new DateTime();
341                DateTime last = new DateTime();
342                first = list.OrderBy(s => s.start_time).ToList().First().start_time;
343                last = list.OrderBy(s => s.start_time).ToList().Last().start_time;
344                gLog.Verbose.Debug.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
345                gLog.Verbose.Debug.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
346                var range = DateTimeRange.Create(first, last);
347                return range;
348            }
349    
350            public List<IOldNewProgram> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> source_invalid)
351            {
352                source_invalid = new List<IPROGRAMME>();
353                List<IOldNewProgram> source_valid = new List<IOldNewProgram>();
354                gbpvr_programs = gbpvr_programs.OrderBy(s => s.start_time).ToList();
355                xmltv_programs = xmltv_programs.OrderBy(s => DateTime.Parse(s.Start)).ToList();
356                gbpvr_programs.TrimExcess();
357                xmltv_programs.TrimExcess();
358    
359                double total = gbpvr_programs.Count;
360                double index = 0;
361                double progress = 0;
362                foreach (var program in gbpvr_programs)
363                {
364                    progress = 100.0 * (index / total);
365                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Filtering GBPVR Programs: {0:00}%", (int)progress)));
366                    // find an entry in xmltv_programs by Channel Number & StartDate                
367                    var program_xmltv_entry = program.AsXMLTVProgramDefinition(this);
368                    var xmltv_entry = xmltv_programs.Find(s => s.ChannelNumber == program_xmltv_entry.ChannelNumber && s.Start == program_xmltv_entry.Start);
369                    if (xmltv_entry == null)
370                    {
371                        // xmltv entry was not found
372                        source_invalid.Add(program);
373                    }
374                    else
375                    {
376                        // check if the xmltv entry has different data from the current program
377                        if (!xmltv_entry.Equals(program_xmltv_entry))
378                        {
379                            // data is different
380                            var updated_program = program;
381    
382                            if (program_xmltv_entry.Title != xmltv_entry.Title)
383                            {
384                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing title", updated_program.oid);
385                                updated_program.name = xmltv_entry.Title;
386                            }
387                            if (program_xmltv_entry.SubTitle != xmltv_entry.SubTitle)
388                            {
389                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing sub_title", updated_program.oid);
390                                updated_program.sub_title = xmltv_entry.SubTitle;
391                            }
392                            if (program_xmltv_entry.Stop != xmltv_entry.Stop)
393                            {
394                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing end_time", updated_program.oid);
395                                updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);
396                            }
397                            if (program_xmltv_entry.Start != xmltv_entry.Start)
398                            {
399                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing start_time", updated_program.oid);
400                                updated_program.start_time = DateTime.Parse(xmltv_entry.Start);
401                            }
402                            if (program_xmltv_entry.Description != xmltv_entry.Description)
403                            {
404                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing description", updated_program.oid);
405                                updated_program.description = xmltv_entry.Description;
406                            }
407    
408                            var updated_xmltv_entry = updated_program.AsXMLTVProgramDefinition(this);
409                            if (!xmltv_entry.Equals(updated_xmltv_entry))
410                            {
411                                throw new Exception(string.Format("Program oid '{0}' was not properly updated.", updated_program.oid));
412                            }
413                            source_valid.Add(new OldNewProgram(program, updated_program));
414                        }
415                        else
416                        {
417                            // data is the same
418                            source_valid.Add(new OldNewProgram(program, program));
419                        }
420                    }
421                    index++;
422                }
423                gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);
424                gLog.Info.WriteLine("Total Valid GB-PVR Programs: 0x{0:x8}", source_valid.Count);
425                gLog.Info.WriteLine("Total Invalid GB-PVR Programs: 0x{0:x8}", source_invalid.Count);
426                gLog.Info.WriteLine("Total GB-PVR Programs (Valid+Invalid): 0x{0:x8} == 0x{1:x8}", source_valid.Count + source_invalid.Count, gbpvr_programs.Count);
427                #region old-code
428                //List<OldNewProgram> source_update = new List<OldNewProgram>();
429                ////if (range == null)
430                ////{
431                ////    gLog.Warn.WriteLine("The DateTimeRange passed in is null...returning the original program list");
432                ////    return list;
433                ////}
434                ////gLog.Warn.WriteLine("FilterProgramsByDateRange has not been implemented");            
435                //double total = gbpvr_programs.Count;
436                //double index = 0;
437                //double progress = 0;
438                //foreach (var program in gbpvr_programs)
439                //{  
440                //    progress = 100.0 * (index / total);
441                //    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Filtering GBPVR Programs: {0:00}%", (int)progress)));                
442                //    var channel_oid = program.channel_oid;
443                //    var channel = this.Channels.Find(s => s.oid == channel_oid);
444                //    var start_date = program.start_time;
445                //    //var xmltv_entry_list = xmltv_programs.FindAll(s => s.ChannelNumber == channel.channel_number && s.Start == start_date.ToDateTimeString());
446                //    var query = from c in xmltv_programs
447                //                where
448                //                c.ChannelNumber == channel.channel_number &&
449                //                c.Start == start_date.ToDateTimeString()
450                //                select c;
451                //    IProgramDefinition xmltv_entry = null;
452                //    if (query.Count()-1 > 0)
453                //    {
454                //        gLog.Verbose.Error.WriteLine("Found more than one entry: Matching channel='{0}' and start='{1}'", channel.channel_number, start_date.ToDateTimeString());
455                //        gLog.Verbose.Error.WriteLine("    GB-PVR Program Data: oid='{0}' channel_oid='{1}' name='{2}' sub_title='{3}' description='{4}'", program.oid, program.channel_oid, program.name, program.sub_title, program.description);
456                //        if (Debugger.IsAttached)
457                //        {                      
458                //            gLog.Error.WriteLine("    Found: {0} matching entries", query.Count());
459                //            int k_index = 0;
460                //            foreach (var k in query)
461                //            {
462                //                gLog.Verbose.Error.WriteLine("    query[{0}]: channel='{1}' start='{2}' ('{3}') title='{4}' subtitle='{5}' description='{6}'", k_index, k.ChannelNumber, k.Start, DateTime.Parse(k.Start).ToString("yyyy/MM/dd HH:mm:ss.fffffff"), k.Title, k.SubTitle, k.Description);
463                //                k_index++;
464                //            }
465                //            Debugger.Break();
466                //        }
467                //    }
468                //    else
469                //    {
470                //        xmltv_entry = query.FirstOrDefault();
471                //    }
472                //    if (xmltv_entry == null)
473                //    {
474                //        //gLog.Verbose.Warn.WriteLine("Invalidating GB-PVR Program: oid='{0}' channel_oid='{1}' title='{2}' start='{3}'", program.oid, program.channel_oid, program.name, program.start_time.ToDateTimeString());
475                //        source_invalid.Add(program);                  
476                //    }
477                //    else
478                //    {
479                //        //gLog.Verbose.Warn.WriteLine("Updating GB-PVR Program (if needed): oid='{0}' channel_oid='{1}' title='{2}' subtitle='{3}' start='{4}'", program.oid, program.channel_oid, program.name, program.sub_title, program.start_time.ToDateTimeString());
480                //        var updated_program = program;
481                //        bool needsupdate = false;
482                //        if (xmltv_entry.Title != program.name)
483                //        {
484                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
485                //            //gLog.Verbose.Warn.WriteLine("        Old Title: {0}", program.name);
486                //            //gLog.Verbose.Warn.WriteLine("        New Title: {0}", xmltv_entry.Title);
487                //            updated_program.name = xmltv_entry.Title;
488                //            needsupdate = true;
489                //        }
490                //        if (xmltv_entry.SubTitle != program.sub_title)
491                //        {
492                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
493                //            //gLog.Verbose.Warn.WriteLine("        Old SubTile: {0}", program.sub_title);
494                //            //gLog.Verbose.Warn.WriteLine("        New SubTile: {0}", xmltv_entry.SubTitle);
495                //            updated_program.sub_title = xmltv_entry.SubTitle;
496                //            needsupdate = true;
497                //        }
498                //        if (xmltv_entry.Description != program.description)
499                //        {
500                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
501                //            //gLog.Verbose.Warn.WriteLine("        Old Descption: {0}", program.description);
502                //            //gLog.Verbose.Warn.WriteLine("        New Descption: {0}", xmltv_entry.Description);
503                //            updated_program.description = xmltv_entry.Description;
504                //            needsupdate = true;
505                //        }
506                //        if (DateTime.Parse(xmltv_entry.Start) != program.start_time)
507                //        {
508                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
509                //            //gLog.Verbose.Warn.WriteLine("        Old StartTime: {0}", program.start_time.ToDateTimeString());
510                //            //gLog.Verbose.Warn.WriteLine("        New StartTime: {0}", DateTime.Parse(xmltv_entry.Start).ToDateTimeString());
511                //            updated_program.start_time = DateTime.Parse(xmltv_entry.Start);
512                //            needsupdate = true;
513                //        }
514                //        if (DateTime.Parse(xmltv_entry.Stop) != program.end_time)
515                //        {
516                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
517                //            //gLog.Verbose.Warn.WriteLine("        Old EndTime: {0}", program.end_time.ToDateTimeString());
518                //            //gLog.Verbose.Warn.WriteLine("        New EndTime: {0}", DateTime.Parse(xmltv_entry.Stop).ToDateTimeString());
519                //            updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);
520                //            needsupdate = true;
521                //        }                    
522                //        if (needsupdate)
523                //        {
524                //            OldNewProgram p = new OldNewProgram();
525                //            p.OldProgram = program;
526                //            p.NewProgram = updated_program;
527                //            source_update.Add(p);
528                //        }
529                //        source_valid.Add(updated_program);
530                //    }
531                //    index++;
532                //}
533                //source_valid = source_valid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();
534                //source_invalid = source_invalid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();
535                //if (source_invalid.Count > 0)
536                //{
537                //    double source_invalid_count = source_valid.Count;
538                //    double source_invalid_index = 0;
539                //    double source_invalid_progress = 0;
540                //    foreach (var old_program in source_invalid)
541                //    {
542                //        source_invalid_progress = 100.0 * (source_invalid_index / source_invalid_count);
543                //        gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_invalid_progress, string.Format("Removing old GBPVR Programs: {0:00}%", (int)source_invalid_progress)));    
544                //        // remove database entry
545                //        if (!RemoveProgramDatabaseEntry(old_program))
546                //        {
547                //            gLog.Error.WriteLine("Failed to remove program with oid: '{0}'", old_program.oid);
548                //        }
549                //        else
550                //        {
551                //            gLog.Verbose.Info.WriteLine("Removed program with oid: '{0}'", old_program.oid);
552                //        }
553                //        source_invalid_index++;
554                //    }
555                //}
556                //else
557                //{
558                //    gLog.Info.WriteLine("No old GB-PVR Programs needed to be removed.");
559                //}
560                //if (source_update.Count > 0)
561                //{
562                //    double source_update_count = source_valid.Count;
563                //    double source_update_index = 0;
564                //    double source_update_progress = 0;
565                //    foreach (var p in source_update)
566                //    {
567                //        source_update_progress = 100.0 * (source_update_index / source_update_count);
568                //        gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_update_progress, string.Format("Updating GBPVR Programs: {0:00}%", (int)source_update_progress)));    
569                //        // remove database entry
570                //        if (!UpdateProgramDatabaseEntry(p.OldProgram,p.NewProgram))
571                //        {
572                //            gLog.Error.WriteLine("Failed to update program with oid: '{0}'", p.OldProgram.oid);
573                //        }
574                //        else
575                //        {
576                //            gLog.Verbose.Info.WriteLine("Upated program with oid: '{0}'", p.OldProgram.oid);
577                //        }
578                //        source_update_index++;
579                //    }
580                //}
581                //else
582                //{
583                //    gLog.Info.WriteLine("No GB-PVR Programs needed to be updated.");
584                //}
585                //gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);
586                //gLog.Info.WriteLine("Updated: 0x{0:x8} GB-PVR Programs", source_valid.Count);
587                //gLog.Info.WriteLine("Removed: 0x{0:x8} GB-PVR Programs", source_invalid.Count);
588                //gLog.Info.WriteLine("Total GB-PVR Programs (Updated & Removed): 0x{0:x8}", source_valid.Count + source_invalid.Count);
589                #endregion
590    
591                return source_valid;
592            }
593          #endregion          #endregion
594    
595    
# Line 233  namespace GBPVRProgramDatabaseFixer Line 609  namespace GBPVRProgramDatabaseFixer
609                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
610                  {                  {
611                      con.Open();                      con.Open();
612                      string command_text = string.Format("select * from {0};", TABLES.PROGRAMME);                      string command_text = string.Format("select * from {0};", TABLES.CHANNEL);
613                      gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);                      gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
614                      using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))                      using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
615                      {                      {
# Line 288  namespace GBPVRProgramDatabaseFixer Line 664  namespace GBPVRProgramDatabaseFixer
664                  return false;                  return false;
665              }              }
666          }          }
667            private void ReadChannelData()
         private void ReadProgrammeData()  
668          {          {
669              try              try
670              {              {
671                  List<IPROGRAMME> programs = new List<IPROGRAMME>();                  List<ICHANNEL> channels = new List<ICHANNEL>();
672                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
673                  {                  {
674                      con.Open();                      try
                     string command_text = string.Format("select * from {0};", TABLES.PROGRAMME);  
                     gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);  
                     using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))  
675                      {                      {
676                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
677                            string command_text = string.Format("select * from {0};", TABLES.CHANNEL);
678                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
679                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
680                          {                          {
681                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
682                              {                              {
683                                  gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);                                  if (!r.HasRows)
684                                    {
685                                        gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
686                                    }
687                                    else
688                                    {
689                                        while (r.Read())
690                                        {
691                                            CHANNEL channel = new CHANNEL();
692                                            for (int i = 0; i < r.FieldCount; i++)
693                                            {
694                                                CHANNEL.Create(ref channel, r, i);
695                                            }
696                                            channels.Add(channel);
697                                        }
698                                    }
699                              }                              }
700                              else                          }
701                        }
702                        catch (SQLiteException ex)
703                        {
704                            gLog.Error.WriteLine(ex.ToString());
705                        }
706                        finally
707                        {
708                            con.Close();
709                        }
710                    }
711                    this.Channels = channels;
712                }
713                catch (Exception ex)
714                {
715                    gLog.Error.WriteLine(ex.ToString());
716                }
717            }
718            private void ReadProgrammeData()
719            {
720                try
721                {
722                    List<IPROGRAMME> programs = new List<IPROGRAMME>();
723                    using (SQLiteConnection con = CreateConnection())
724                    {
725                        try
726                        {
727                            con.Open();
728                            string command_text = string.Format("select * from {0};", TABLES.PROGRAMME);
729                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
730                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
731                            {
732                                using (SQLiteDataReader r = cmd.ExecuteReader())
733                              {                              {
734                                  while (r.Read())                                  if (!r.HasRows)
735                                  {                                  {
736                                      PROGRAMME program = new PROGRAMME();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
737                                      for (int i = 0; i < r.FieldCount; i++)                                  }
738                                    else
739                                    {
740                                        while (r.Read())
741                                      {                                      {
742                                          PROGRAMME.Create(ref program, r, i);                                          PROGRAMME program = new PROGRAMME();
743                                            for (int i = 0; i < r.FieldCount; i++)
744                                            {
745                                                PROGRAMME.Create(ref program, r, i);
746                                            }
747                                            programs.Add(program);
748                                      }                                      }
                                     programs.Add(program);  
749                                  }                                  }
750                              }                              }
751                          }                          }
752                      }                      }
753                      con.Clone();                      catch (SQLiteException ex)
754                        {
755                            gLog.Error.WriteLine(ex.ToString());
756                        }
757                        finally
758                        {
759                            con.Close();
760                        }
761                  }                  }
762                  this.Programs = programs;                  this.Programs = programs;
763              }              }
# Line 337  namespace GBPVRProgramDatabaseFixer Line 773  namespace GBPVRProgramDatabaseFixer
773                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();
774                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
775                  {                  {
776                      con.Open();                      try
                     string command_text = string.Format("select * from {0};", TABLES.RECORDING_SCHEDULE);  
                     gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);  
                     using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))  
777                      {                      {
778                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
779                            string command_text = string.Format("select * from {0};", TABLES.RECORDING_SCHEDULE);
780                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
781                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
782                          {                          {
783                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
784                              {                              {
785                                  while (r.Read())                                  if (!r.HasRows)
786                                  {                                  {
787                                      RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
788                                      for (int i = 0; i < r.FieldCount; i++)                                  }
789                                    else
790                                    {
791                                        while (r.Read())
792                                      {                                      {
793                                          RECORDING_SCHEDULE.Create(ref recording, r, i);                                          RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();
794                                            for (int i = 0; i < r.FieldCount; i++)
795                                            {
796                                                RECORDING_SCHEDULE.Create(ref recording, r, i);
797                                            }
798                                            recordings.Add(recording);
799                                      }                                      }
   
                                     recordings.Add(recording);  
800                                  }                                  }
801                              }                              }
802                          }                          }
803                      }                      }
804                      con.Clone();                      catch (SQLiteException ex)
805                        {
806                            gLog.Error.WriteLine(ex.ToString());
807                        }
808                        finally
809                        {
810                            con.Close();
811                        }
812                  }                  }
813                  this.Recordings = recordings;                  this.Recordings = recordings;
814              }              }
# Line 372  namespace GBPVRProgramDatabaseFixer Line 817  namespace GBPVRProgramDatabaseFixer
817                  gLog.Error.WriteLine(ex.ToString());                  gLog.Error.WriteLine(ex.ToString());
818              }              }
819          }          }
820    
821            public void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs)
822            {            
823                gLog.Info.WriteLine("Removing all gbpvr programs.");
824                //double total = programs.Count;
825                //double index = 0;
826                //double progress = 0;
827                //foreach (var program in programs)
828                //{
829                //    progress = 100.0 * (index / total);
830                //    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Removing GBPVR Programs: {0:00}%", (int)progress)));
831                //    if (!RemoveProgramDatabaseEntry(program))
832                //    {
833                //        gLog.Error.WriteLine("Failed to remove program with oid: {0}", program.oid);
834                //    }
835                //    index++;
836                //}
837                Stopwatch st = new Stopwatch();
838                st.Start();
839                if (!RemoveAllProgramDatabaseEntries())
840                {
841                    gLog.Error.WriteLine("Failed to remove one or more program(s)");
842                }
843                st.Stop();
844                gLog.Warn.WriteLine("    operation took: {0:0.00000} minutes", st.Elapsed.TotalMinutes);
845            }
846            public void UpdateGBPVRPrograms(List<IOldNewProgram> programs)
847            {
848                int STEP = 500;
849                List<List<IPROGRAMME>> array_list = new List<List<IPROGRAMME>>(); // holds a list of ~STEP programs per index
850                for (int i = 0; i < programs.Count;)
851                {
852                    List<IPROGRAMME> tmp = new List<IPROGRAMME>(STEP);
853                    for (int j = 0; j < STEP; j++)
854                    {
855                        try
856                        {
857                            tmp.Add(programs[i + j].NewProgram);
858                        }
859                        catch { }
860                    }
861                    tmp.TrimExcess();
862                    array_list.Add(tmp);
863                    i += STEP;
864                }
865                array_list.TrimExcess();
866    
867                int total = programs.Count;
868                int index = 0;
869                double progress = 0;
870                Stopwatch st = new Stopwatch();
871                st.Start();
872                foreach (var p in array_list)
873                {
874                    progress = 100.0 * (index / total);              
875                    //gLog.Info.WriteLine("Inserting {0} gbpvr programs.", p.Count);  
876                    if (!InsertProgramEntryDatabase(p))
877                    {
878                        gLog.Error.WriteLine("Failed to insert one or more program(s)");
879                    }              
880                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Inserting GBPVR Programs: {0:00}%", (int)progress)));
881                    index += p.Count;
882                }
883                st.Stop();
884                gLog.Warn.WriteLine("    operation took: {0:0.00000} minutes", st.Elapsed.TotalMinutes);
885            }
886    
887            private bool RemoveAllProgramDatabaseEntries()
888            {
889                bool result = false;
890                try
891                {
892                    using (SQLiteConnection con = CreateConnection())
893                    {
894                        try
895                        {
896                            //gLog.Verbose.Info.WriteLine("Removing old program with oid: '{0}'", old_program.oid);
897                            con.Open();
898                            string command_text = string.Format(@"DELETE FROM [{0}];", TABLES.PROGRAMME);
899                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
900                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
901                            {
902                                //cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));
903                                int rowsupdated = cmd.ExecuteNonQuery();
904                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
905                            }
906                            result = true;
907                        }
908                        catch (SQLiteException ex)
909                        {
910                            gLog.Error.WriteLine(ex.ToString());
911                            result = false;
912                        }
913                        finally
914                        {
915                            con.Close();
916                        }
917                    }
918                }
919                catch (Exception ex)
920                {
921                    gLog.Error.WriteLine(ex.ToString());
922                    result = false;
923                }
924                return result;
925            }
926            private bool RemoveProgramDatabaseEntry(IPROGRAMME old_program)
927            {
928                bool result = false;
929                try
930                {
931                    using (SQLiteConnection con = CreateConnection())
932                    {
933                        try
934                        {
935                            //gLog.Verbose.Info.WriteLine("Removing old program with oid: '{0}'", old_program.oid);
936                            con.Open();
937                            string command_text = string.Format(@"DELETE FROM [{0}] WHERE [oid] = @oid;", TABLES.PROGRAMME);
938                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
939                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
940                            {
941                                cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));
942                                int rowsupdated = cmd.ExecuteNonQuery();
943                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
944                            }
945                            result = true;
946                        }
947                        catch (SQLiteException ex)
948                        {
949                            gLog.Error.WriteLine(ex.ToString());
950                            result = false;
951                        }
952                        finally
953                        {
954                            con.Close();
955                        }
956                    }
957                }
958                catch (Exception ex)
959                {
960                    gLog.Error.WriteLine(ex.ToString());
961                    result = false;
962                }
963                return result;
964            }
965            private bool InsertProgramEntryDatabase(List<IPROGRAMME> list)
966            {
967                bool result = false;
968                try
969                {
970                    using (SQLiteConnection con = CreateConnection())
971                    {
972                        try
973                        {
974                            //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
975                            con.Open();
976                            //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
977                            string command_text = string.Empty;
978                            command_text = BuildGBPVRMultiInsertCommand(list);
979                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
980                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
981                            {                          
982                                int rowsupdated = cmd.ExecuteNonQuery();
983                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
984                            }
985    
986                            result = true;
987                        }
988                        catch (SQLiteException ex)
989                        {
990                            gLog.Error.WriteLine(ex.ToString());
991                            result = false;
992                        }
993                        finally
994                        {
995                            con.Close();
996                        }
997                    }
998                }
999                catch (Exception ex)
1000                {
1001                    gLog.Error.WriteLine(ex.ToString());
1002                    result = false;
1003                }
1004                return result;
1005            }
1006    
1007            private string BuildGBPVRMultiInsertCommand(List<IPROGRAMME> list)
1008            {
1009                StringBuilder builder = new StringBuilder();
1010                /*
1011                    insert into table1 (field1,field2) values (value1,value2);
1012                    insert into table1 (field1,field2) values (value1,value2);
1013                    insert into table1 (field1,field2) values (value1,value2);
1014                    insert into table1 (field1,field2) values (value1,value2)
1015                 */
1016                builder.AppendLine("begin transaction;");
1017                foreach (var t in list)
1018                {
1019                    builder.AppendLine(BuildGBPVRSingleInsertCommand(t));
1020                }
1021                builder.AppendLine("end transaction;");
1022                return builder.ToString();
1023            }
1024    
1025            private string BuildGBPVRSingleInsertCommand(IPROGRAMME program)
1026            {
1027                StringBuilder builder = new StringBuilder();
1028                builder.AppendFormat("insert into {0} (oid,name,sub_title,description,start_time,end_time,channel_oid,unique_identifier,rating) values (", TABLES.PROGRAMME);
1029                builder.AppendFormat("{0},",program.oid);
1030                builder.AppendFormat("\"{0}\",", program.name);
1031                builder.AppendFormat("\"{0}\",", program.sub_title);
1032                builder.AppendFormat("\"{0}\",", program.description);
1033                builder.AppendFormat("'{0}',", program.start_time);
1034                builder.AppendFormat("'{0}',", program.end_time);
1035                builder.AppendFormat("{0},", program.channel_oid);
1036                builder.AppendFormat("\"{0}\",", program.unique_identifier);
1037                builder.AppendFormat("\"{0}\");", program.rating);
1038                return builder.ToString();
1039            }
1040          
1041      }      }
1042  }  }

Legend:
Removed from v.157  
changed lines
  Added in v.195

  ViewVC Help
Powered by ViewVC 1.1.22