/[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 179 by william, Sat Mar 16 17:13:23 2013 UTC revision 228 by william, Sun Mar 17 04:02:57 2013 UTC
# Line 11  using libxmltv.Interfaces; Line 11  using libxmltv.Interfaces;
11  using libxmltv.Core;  using libxmltv.Core;
12  namespace GBPVRProgramDatabaseFixer  namespace GBPVRProgramDatabaseFixer
13  {  {
14        public interface ICloneable<T>
15        {
16            T Clone();
17        }
18        public interface IOldNewProgram
19        {
20            SQLLITE.IPROGRAMME OldProgram { get; }
21            SQLLITE.IPROGRAMME NewProgram { get; }
22        }
23      public interface ISQLLITE      public interface ISQLLITE
24      {      {
25          List<SQLLITE.IPROGRAMME> Programs { get; }          List<SQLLITE.IPROGRAMME> Programs { get; }
26          List<SQLLITE.IRECORDING_SCHEDULE> Recordings { get; }          List<SQLLITE.IRECORDING_SCHEDULE> Recordings { get; }
27          List<SQLLITE.ICHANNEL> Channels { get; }          List<SQLLITE.ICHANNEL> Channels { get; }
28          IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs);          IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs);
29          List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> removed_programs);          List<IOldNewProgram> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> removed_programs);
30    
31            void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs);
32            void UpdateGBPVRPrograms(List<IOldNewProgram> programs);
33    
34      }      }
35      public class SQLLITE : ISQLLITE      public class SQLLITE : ISQLLITE
36      {      {
37          private struct OldNewProgram          private class OldNewProgram : IOldNewProgram
38          {          {
39              public IPROGRAMME OldProgram;              public OldNewProgram() : this(new PROGRAMME()) { }
40              public IPROGRAMME NewProgram;              public OldNewProgram(IPROGRAMME _old) : this(_old,_old) {  }
41                public OldNewProgram(IPROGRAMME _old, IPROGRAMME _new) { OldProgram = _old; NewProgram = _new; }
42    
43                public IPROGRAMME OldProgram { get; private set; }
44                public IPROGRAMME NewProgram { get; private set; }
45          }          }
46          public static ISQLLITE Create(string database, EventHandler<EventArgs> OnInstanceCreated)          public static ISQLLITE Create(string database, EventHandler<EventArgs> OnInstanceCreated)
47          {          {
# Line 33  namespace GBPVRProgramDatabaseFixer Line 49  namespace GBPVRProgramDatabaseFixer
49          }          }
50    
51          #region DATABASE DEFINITIONS          #region DATABASE DEFINITIONS
52            #region BaseDatabaseDefinition
         public interface ICHANNEL  
         {  
             Int64 oid { get; }  
             String name { get; }  
             String channelID { get; }  
             Int64 channel_number { get; }  
             String favourite_channel { get; }  
             String display_name { get; }  
         }  
         private class CHANNEL : ICHANNEL  
         {  
             public CHANNEL()  
             {  
                 BaseDatabaseDefinition<CHANNEL>.CreateDefault(this);  
             }  
             //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }  
   
             public static void Create(ref CHANNEL instance, SQLiteDataReader r, int index)  
             {  
                 BaseDatabaseDefinition<CHANNEL>.Create(ref instance, r, index);  
             }  
             #region ICHANNEL members  
             public Int64 oid { get; set; }  
             public String name { get; set; }  
             public String channelID { get; set; }  
             public Int64 channel_number { get; set; }  
             public String favourite_channel { get; set; }  
             public String display_name { get; set; }  
             #endregion  
         }  
         public interface IRECORDING_SCHEDULE  
         {  
             Int64 oid { get; }  
             Int64 programme_oid { get; }  
             Int64 capture_source_oid { get; }  
             Int16 status { get; }  
             String filename { get; }  
             Int64 recording_type { get; }  
             Int64 recording_group { get; }  
             DateTime manual_start_time { get; }  
             DateTime manual_end_time { get; }  
             Int64 manual_channel_oid { get; }  
             Int64 quality_level { get; }  
             Int64 pre_pad_minutes { get; }  
             Int64 post_pad_minutes { get;}  
             Int32 priority { get; }  
             String conversion_profile { get; }  
         }  
   
53          private static class BaseDatabaseDefinition<T>          private static class BaseDatabaseDefinition<T>
54          {          {
55              public static void CreateDefault(T instance)              public static void CreateDefault(T instance)
# Line 118  namespace GBPVRProgramDatabaseFixer Line 85  namespace GBPVRProgramDatabaseFixer
85                      throw ex;                      throw ex;
86                  }                  }
87              }              }
88                public static void Create(T source, ref T destination)
89                {
90                    Type t = source.GetType();
91                    var props = t.GetProperties();
92                    foreach (var prop in props)
93                    {
94                        try
95                        {
96                            object value = prop.GetValue(source, null);
97                            prop.SetValue(destination, value, null);
98                        }
99                        catch (Exception ex)
100                        {
101                            throw ex;
102                        }
103                    }
104                }
105              public static void Create(ref T instance, SQLiteDataReader r, int index)              public static void Create(ref T instance, SQLiteDataReader r, int index)
106              {                              {
107                  string field_name = r.GetName(index);                  string field_name = r.GetName(index);
108                  Type field_type = r.GetFieldType(index);                  Type field_type = r.GetFieldType(index);
109                  object field_value = r.GetValue(index);                  object field_value = r.GetValue(index);
# Line 144  namespace GBPVRProgramDatabaseFixer Line 128  namespace GBPVRProgramDatabaseFixer
128                                  {                                  {
129                                      prop.SetValue(instance, field_value, null);                                      prop.SetValue(instance, field_value, null);
130                                  }                                  }
131                                    
132                              }                              }
133                              catch (Exception ex)                              catch (Exception ex)
134                              {                              {
135                                  throw ex;                                  throw ex;
136                              }                              }
# Line 161  namespace GBPVRProgramDatabaseFixer Line 145  namespace GBPVRProgramDatabaseFixer
145    
146              }              }
147          }          }
148            #endregion
149            public interface ICHANNEL : ICloneable<ICHANNEL>
150            {
151                Int64 oid { get; }
152                String name { get; }
153                String channelID { get; }
154                Int64 channel_number { get; }
155                String favourite_channel { get; }
156                String display_name { get; }
157            }
158            private class CHANNEL : ICHANNEL, ICloneable<CHANNEL>
159            {
160                public CHANNEL()
161                {
162                    BaseDatabaseDefinition<CHANNEL>.CreateDefault(this);
163                }
164                //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }
165    
166                public static void Create(ref CHANNEL instance, SQLiteDataReader r, int index)
167                {
168                    BaseDatabaseDefinition<CHANNEL>.Create(ref instance, r, index);
169                }
170                #region ICHANNEL members
171                public Int64 oid { get; set; }
172                public String name { get; set; }
173                public String channelID { get; set; }
174                public Int64 channel_number { get; set; }
175                public String favourite_channel { get; set; }
176                public String display_name { get; set; }
177                #endregion
178    
179          private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE              ICHANNEL ICloneable<ICHANNEL>.Clone()
180                {
181                    return Clone();
182                }
183                public CHANNEL Clone()
184                {
185                    CHANNEL p = new CHANNEL();
186                    BaseDatabaseDefinition<CHANNEL>.Create(this, ref p);
187                    return p;
188                }
189            }
190            public interface IRECORDING_SCHEDULE : ICloneable<IRECORDING_SCHEDULE>
191            {
192                Int64 oid { get; }
193                Int64 programme_oid { get; }
194                Int64 capture_source_oid { get; }
195                Int16 status { get; }
196                String filename { get; }
197                Int64 recording_type { get; }
198                Int64 recording_group { get; }
199                DateTime manual_start_time { get; }
200                DateTime manual_end_time { get; }
201                Int64 manual_channel_oid { get; }
202                Int64 quality_level { get; }
203                Int64 pre_pad_minutes { get; }
204                Int64 post_pad_minutes { get; }
205                Int32 priority { get; }
206                String conversion_profile { get; }
207            }
208            private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE, ICloneable<RECORDING_SCHEDULE>
209          {          {
210              public RECORDING_SCHEDULE()              public RECORDING_SCHEDULE()
211              {              {
212                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);
213              }              }
214              //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); }
215    
216              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)
217              {              {
218                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);
219                }
220                IRECORDING_SCHEDULE ICloneable<IRECORDING_SCHEDULE>.Clone()
221                {
222                    return Clone();
223                }
224                public RECORDING_SCHEDULE Clone()
225                {
226                    RECORDING_SCHEDULE p = new RECORDING_SCHEDULE();
227                    BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, ref p);
228                    return p;
229              }              }
   
230              #region IRECORDING_SCHEDULE members              #region IRECORDING_SCHEDULE members
231              public Int64 oid { get; set;}              public Int64 oid { get; set; }
232              public Int64 programme_oid { get; set;}              public Int64 programme_oid { get; set; }
233              public Int64 capture_source_oid { get; set;}              public Int64 capture_source_oid { get; set; }
234              public Int16 status { get; set; }              public Int16 status { get; set; }
235              public String filename { get; set; }              public String filename { get; set; }
236              public Int64 recording_type { get;set; }              public Int64 recording_type { get; set; }
237              public Int64 recording_group { get; set;}              public Int64 recording_group { get; set; }
238              public DateTime manual_start_time { get; set;}              public DateTime manual_start_time { get; set; }
239              public DateTime manual_end_time { get; set; }              public DateTime manual_end_time { get; set; }
240              public Int64 manual_channel_oid { get; set; }              public Int64 manual_channel_oid { get; set; }
241              public Int64 quality_level { get; set; }              public Int64 quality_level { get; set; }
# Line 192  namespace GBPVRProgramDatabaseFixer Line 244  namespace GBPVRProgramDatabaseFixer
244              public Int32 priority { get; set; }              public Int32 priority { get; set; }
245              public String conversion_profile { get; set; }              public String conversion_profile { get; set; }
246              #endregion              #endregion
         }  
247    
248          public interface IPROGRAMME              
249            }
250            public interface IPROGRAMME : IEquatable<IPROGRAMME>, ICloneable<IPROGRAMME>
251          {          {
252              Int64 oid { get; set; }              Int64 oid { get; set; }
253              String name { get; set; }              String name { get; set; }
# Line 206  namespace GBPVRProgramDatabaseFixer Line 259  namespace GBPVRProgramDatabaseFixer
259              String unique_identifier { get; set; }              String unique_identifier { get; set; }
260              String rating { get; set; }              String rating { get; set; }
261    
262                string ToString();
263              IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite);              IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite);
264          }          }
265          private class PROGRAMME : IPROGRAMME          private class PROGRAMME : IPROGRAMME, ICloneable<PROGRAMME>
266          {          {
267              public PROGRAMME()            
268                IPROGRAMME ICloneable<IPROGRAMME>.Clone()
269                {
270                    return Clone();
271                }
272                public PROGRAMME Clone()
273                {
274                    PROGRAMME p = new PROGRAMME();
275                    BaseDatabaseDefinition<PROGRAMME>.Create(this, ref p);
276                    return p;
277                }
278                public PROGRAMME()
279              {              {
280                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);
281              }              }
282              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }
283              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)
# Line 232  namespace GBPVRProgramDatabaseFixer Line 297  namespace GBPVRProgramDatabaseFixer
297              public IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite)              public IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite)
298              {              {
299                  ProgramList.ProgramDefintion definition = new ProgramList.ProgramDefintion();                  ProgramList.ProgramDefintion definition = new ProgramList.ProgramDefintion();
300    
301                  var channel = sqllite.Channels.Find(s => s.oid == this.channel_oid);                  var channel = sqllite.Channels.Find(s => s.oid == this.channel_oid);
302                  definition.ChannelName = channel.display_name;                  var channelname = channel.display_name;
303                  definition.ChannelNumber = (int)channel.channel_number;                  var split = channelname.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
304                    definition.ChannelNumber = Convert.ToInt32(split.First());
305                    definition.ChannelName = string.IsNullOrEmpty(split.Last()) ? string.Empty : split.Last().ToString();
306                  definition.Description = this.description;                  definition.Description = this.description;
307                  definition.Start = this.start_time.ToDateTimeString();                  definition.Start = this.start_time.ToDateTimeString();
308                  definition.Stop = this.end_time.ToDateTimeString();                  definition.Stop = this.end_time.ToDateTimeString();
309                  definition.SubTitle = this.sub_title;                  definition.SubTitle = this.sub_title;
310                  definition.Title = this.name;                  definition.Title = this.name;
311                    definition.Rating = this.rating;
312                  return definition;                  return definition;
313              }              }
314              #endregion              #endregion
315    
316                public bool Equals(IPROGRAMME other)
317                {
318                    return this.ToString() == other.ToString();
319                }
320                public override string ToString()
321                {
322                    StringBuilder builder = new StringBuilder();
323    
324                    builder.AppendFormat("oid: '{0}' ", oid);
325                    builder.AppendFormat("name: '{0}' ", name);
326                    builder.AppendFormat("sub_title: '{0}' ", sub_title);
327                    builder.AppendFormat("description: '{0}' ", description);
328                    builder.AppendFormat("start_time: '{0}' ", start_time.ToDateTimeString());
329                    builder.AppendFormat("end_time: '{0}' ", end_time.ToDateTimeString());
330                    builder.AppendFormat("channel_oid: '{0}' ", channel_oid);
331                    builder.AppendFormat("unique_identifier: '{0}' ", unique_identifier);
332                    builder.AppendFormat("rating: '{0}'", rating);
333    
334                    return builder.ToString();
335                }
336                public override bool Equals(object obj)
337                {
338                    if (obj == null) { throw new ArgumentNullException("obj", "Object to compare cannot be null"); }
339                    if (obj.GetType().IsAssignableFrom(typeof(IPROGRAMME)))
340                    {
341                        return this.Equals((IPROGRAMME)obj);
342                    }
343                    return base.Equals(obj);
344                }
345                public override int GetHashCode()
346                {
347                    return this.ToString().GetHashCode();
348                }
349    
350    
351    
352    
353    
354    
355    
356              
357          }          }
358          #endregion          #endregion
359          private static class TABLES          private static class TABLES
# Line 251  namespace GBPVRProgramDatabaseFixer Line 362  namespace GBPVRProgramDatabaseFixer
362              public const string PROGRAMME = "PROGRAMME";              public const string PROGRAMME = "PROGRAMME";
363              public const string CHANNEL = "CHANNEL";              public const string CHANNEL = "CHANNEL";
364          }          }
365            private string DATABASE_BACKUP_FILE = string.Empty;
366          //public SQLLite() { }          //public SQLLite() { }
367          protected SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)          protected SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)
368          {          {
369              this.OnInstanceCreated = OnInstanceCreated;              this.OnInstanceCreated = OnInstanceCreated;
370              //CreateConnection(database);              //CreateConnection(database);
# Line 273  namespace GBPVRProgramDatabaseFixer Line 384  namespace GBPVRProgramDatabaseFixer
384          [NonSerialized]          [NonSerialized]
385          private EventHandler<EventArgs> _OnInstanceCreated;          private EventHandler<EventArgs> _OnInstanceCreated;
386          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }
387            
388          private void OnCreatedInstance(object sender, EventArgs e)          private void OnCreatedInstance(object sender, EventArgs e)
389          {          {
390              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }
391          }          }
392    
393          private string Database;          private string Database;
394          #region ISQLLITE members                  #region ISQLLITE members
395          public List<IPROGRAMME> Programs { get; private set; }          public List<IPROGRAMME> Programs { get; private set; }
396          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }
397          public List<ICHANNEL> Channels { get; private set; }          public List<ICHANNEL> Channels { get; private set; }
# Line 290  namespace GBPVRProgramDatabaseFixer Line 401  namespace GBPVRProgramDatabaseFixer
401              var list = new List<IPROGRAMME>(programs.ToArray());              var list = new List<IPROGRAMME>(programs.ToArray());
402              DateTime first = new DateTime();              DateTime first = new DateTime();
403              DateTime last = new DateTime();              DateTime last = new DateTime();
404              first = list.OrderBy(s => s.start_time).ToList().First().start_time;                          first = list.OrderBy(s => s.start_time).ToList().First().start_time;
405              last = list.OrderBy(s => s.start_time).ToList().Last().start_time;              last = list.OrderBy(s => s.start_time).ToList().Last().start_time;
406              gLog.Verbose.Debug.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());              gLog.Verbose.Debug.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
407              gLog.Verbose.Debug.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());              gLog.Verbose.Debug.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
# Line 298  namespace GBPVRProgramDatabaseFixer Line 409  namespace GBPVRProgramDatabaseFixer
409              return range;              return range;
410          }          }
411    
412          public List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> source_invalid)          public List<IOldNewProgram> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> source_invalid)
413          {          {
414              source_invalid = new List<IPROGRAMME>();              source_invalid = new List<IPROGRAMME>();
415              gbpvr_programs = gbpvr_programs.OrderBy(s => s.start_time).ToList();                          List<IOldNewProgram> source_valid = new List<IOldNewProgram>();
416              List<SQLLITE.IPROGRAMME> source_valid = new List<IPROGRAMME>();              gbpvr_programs = gbpvr_programs.OrderBy(s => s.start_time).ToList();
417                xmltv_programs = xmltv_programs.OrderBy(s => DateTime.Parse(s.Start)).ToList();
418                gbpvr_programs.TrimExcess();
419                xmltv_programs.TrimExcess();
420    
             List<OldNewProgram> source_update = new List<OldNewProgram>();  
             //if (range == null)  
             //{  
             //    gLog.Warn.WriteLine("The DateTimeRange passed in is null...returning the original program list");  
             //    return list;  
             //}  
             //gLog.Warn.WriteLine("FilterProgramsByDateRange has not been implemented");  
               
421              double total = gbpvr_programs.Count;              double total = gbpvr_programs.Count;
422              double index = 0;              double index = 0;
423              double progress = 0;              double progress = 0;
424              foreach (var program in gbpvr_programs)              foreach (var program in gbpvr_programs)
425              {                {
426                  progress = 100.0 * (index / total);                  progress = 100.0 * (index / total);
427                  gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Filtering GBPVR Programs: {0:00}%", (int)progress)));                                  gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Filtering GBPVR Programs: {0:00}%", (int)progress)));
428                  var channel_oid = program.channel_oid;                  // find an entry in xmltv_programs by Channel Number & StartDate                
429                  var channel = this.Channels.Find(s => s.oid == channel_oid);                  var program_xmltv_entry = program.AsXMLTVProgramDefinition(this);
430                  var start_date = program.start_time;                  var xmltv_entry = xmltv_programs.Find(s => s.ChannelNumber == program_xmltv_entry.ChannelNumber && s.Start == program_xmltv_entry.Start);
                 //var xmltv_entry_list = xmltv_programs.FindAll(s => s.ChannelNumber == channel.channel_number && s.Start == start_date.ToDateTimeString());  
                 var query = from c in xmltv_programs  
                             where  
                             c.ChannelNumber == channel.channel_number &&  
                             c.Start == start_date.ToDateTimeString()  
                             select c;  
   
                 IProgramDefinition xmltv_entry = null;  
                 if (query.Count()-1 > 0)  
                 {  
                     gLog.Verbose.Error.WriteLine("Found more than one entry: Matching channel='{0}' and start='{1}'", channel.channel_number, start_date.ToDateTimeString());  
                     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);  
                     if (Debugger.IsAttached)  
                     {                        
                         gLog.Error.WriteLine("    Found: {0} matching entries", query.Count());  
                         int k_index = 0;  
                         foreach (var k in query)  
                         {  
                             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);  
                             k_index++;  
                         }  
                         Debugger.Break();  
                     }  
                 }  
                 else  
                 {  
                     xmltv_entry = query.FirstOrDefault();  
                 }  
   
431                  if (xmltv_entry == null)                  if (xmltv_entry == null)
432                  {                  {
433                      //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());                      // xmltv entry was not found
434                      source_invalid.Add(program);                                        source_invalid.Add(program);
435                  }                  }
436                  else                  else
437                  {                  {
438                      //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());                      // check if the xmltv entry has different data from the current program
439                      var updated_program = program;                      if (!xmltv_entry.Equals(program_xmltv_entry))
440                      bool needsupdate = false;                      {
441                      if (xmltv_entry.Title != program.name)                          // data is different
442                      {                          var updated_program = program.Clone();
                         //gLog.Verbose.Warn.WriteLine("    Updating:");  
                         //gLog.Verbose.Warn.WriteLine("        Old Title: {0}", program.name);  
                         //gLog.Verbose.Warn.WriteLine("        New Title: {0}", xmltv_entry.Title);  
                         updated_program.name = xmltv_entry.Title;  
                         needsupdate = true;  
                     }  
                     if (xmltv_entry.SubTitle != program.sub_title)  
                     {  
                         //gLog.Verbose.Warn.WriteLine("    Updating:");  
                         //gLog.Verbose.Warn.WriteLine("        Old SubTile: {0}", program.sub_title);  
                         //gLog.Verbose.Warn.WriteLine("        New SubTile: {0}", xmltv_entry.SubTitle);  
                         updated_program.sub_title = xmltv_entry.SubTitle;  
                         needsupdate = true;  
                     }  
                     if (xmltv_entry.Description != program.description)  
                     {  
                         //gLog.Verbose.Warn.WriteLine("    Updating:");  
                         //gLog.Verbose.Warn.WriteLine("        Old Descption: {0}", program.description);  
                         //gLog.Verbose.Warn.WriteLine("        New Descption: {0}", xmltv_entry.Description);  
                         updated_program.description = xmltv_entry.Description;  
                         needsupdate = true;  
                     }  
                     if (DateTime.Parse(xmltv_entry.Start) != program.start_time)  
                     {  
                         //gLog.Verbose.Warn.WriteLine("    Updating:");  
                         //gLog.Verbose.Warn.WriteLine("        Old StartTime: {0}", program.start_time.ToDateTimeString());  
                         //gLog.Verbose.Warn.WriteLine("        New StartTime: {0}", DateTime.Parse(xmltv_entry.Start).ToDateTimeString());  
                         updated_program.start_time = DateTime.Parse(xmltv_entry.Start);  
                         needsupdate = true;  
                     }  
                     if (DateTime.Parse(xmltv_entry.Stop) != program.end_time)  
                     {  
                         //gLog.Verbose.Warn.WriteLine("    Updating:");  
                         //gLog.Verbose.Warn.WriteLine("        Old EndTime: {0}", program.end_time.ToDateTimeString());  
                         //gLog.Verbose.Warn.WriteLine("        New EndTime: {0}", DateTime.Parse(xmltv_entry.Stop).ToDateTimeString());  
                         updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);  
                         needsupdate = true;  
                     }  
                       
                     if (needsupdate)  
                     {  
                         OldNewProgram p = new OldNewProgram();  
                         p.OldProgram = program;  
                         p.NewProgram = updated_program;  
                         source_update.Add(p);  
                     }  
                     source_valid.Add(updated_program);  
                 }  
                 index++;  
             }  
   
443    
444              source_valid = source_valid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();                          if (program_xmltv_entry.Title != xmltv_entry.Title)
445              source_invalid = source_invalid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();                          {
446                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing title", updated_program.oid);
447                                updated_program.name = xmltv_entry.Title;
448                            }
449                            if (program_xmltv_entry.SubTitle != xmltv_entry.SubTitle)
450                            {
451                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing sub_title", updated_program.oid);
452                                updated_program.sub_title = xmltv_entry.SubTitle;
453                            }
454                            if (program_xmltv_entry.Stop != xmltv_entry.Stop)
455                            {
456                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing end_time", updated_program.oid);
457                                updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);
458                            }
459                            if (program_xmltv_entry.Start != xmltv_entry.Start)
460                            {
461                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing start_time", updated_program.oid);
462                                updated_program.start_time = DateTime.Parse(xmltv_entry.Start);
463                            }
464                            if (program_xmltv_entry.Description != xmltv_entry.Description)
465                            {
466                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing description", updated_program.oid);
467                                updated_program.description = xmltv_entry.Description;
468                            }
469    
470              if (source_invalid.Count > 0)                          if(program_xmltv_entry.Rating != xmltv_entry.Rating)
471              {                          {
472                  double source_invalid_count = source_valid.Count;                              gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing rating", updated_program.oid);
473                  double source_invalid_index = 0;                              updated_program.rating = xmltv_entry.Rating;
474                  double source_invalid_progress = 0;                          }
                 foreach (var old_program in source_invalid)  
                 {  
                     source_invalid_progress = 100.0 * (source_invalid_index / source_invalid_count);  
                     gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_invalid_progress, string.Format("Removing old GBPVR Programs: {0:00}%", (int)source_invalid_progress)));      
                     // remove database entry  
                     if (!RemoveProgramDatabaseEntry(old_program))  
                     {  
                         gLog.Error.WriteLine("Failed to remove program with oid: '{0}'", old_program.oid);  
                     }  
                     else  
                     {  
                         gLog.Verbose.Info.WriteLine("Removed program with oid: '{0}'", old_program.oid);  
                     }  
                     source_invalid_index++;  
                 }  
             }  
             else  
             {  
                 gLog.Info.WriteLine("No old GB-PVR Programs needed to be removed.");  
             }  
475    
476              if (source_update.Count > 0)                          var updated_xmltv_entry = updated_program.AsXMLTVProgramDefinition(this);
477              {                          if (!xmltv_entry.Equals(updated_xmltv_entry))
478                  double source_update_count = source_valid.Count;                          {
479                  double source_update_index = 0;                              throw new Exception(string.Format("Program oid '{0}' was not properly updated.", updated_program.oid));
480                  double source_update_progress = 0;                          }
481                  foreach (var p in source_update)                          //source_valid.Add(new OldNewProgram(program, updated_program));
482                  {                          source_valid.Add(new OldNewProgram(program, updated_program));
                     source_update_progress = 100.0 * (source_update_index / source_update_count);  
                     gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_update_progress, string.Format("Updating GBPVR Programs: {0:00}%", (int)source_update_progress)));      
                     // remove database entry  
                     if (!UpdateProgramDatabaseEntry(p.OldProgram,p.NewProgram))  
                     {  
                         gLog.Error.WriteLine("Failed to update program with oid: '{0}'", p.OldProgram.oid);  
483                      }                      }
484                      else                      else
485                      {                      {
486                          gLog.Verbose.Info.WriteLine("Upated program with oid: '{0}'", p.OldProgram.oid);                          // data is the same
487                            //source_valid.Add(new OldNewProgram(program, program));
488                            source_valid.Add(new OldNewProgram(program));
489                      }                      }
                     source_update_index++;  
490                  }                  }
491                    index++;
492              }              }
             else  
             {  
                 gLog.Info.WriteLine("No GB-PVR Programs needed to be updated.");  
             }  
   
493              gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);              gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);
494              gLog.Info.WriteLine("Updated: 0x{0:x8} GB-PVR Programs", source_valid.Count);              gLog.Info.WriteLine("Total Valid GB-PVR Programs: 0x{0:x8}", source_valid.Count);
495              gLog.Info.WriteLine("Removed: 0x{0:x8} GB-PVR Programs", source_invalid.Count);              gLog.Info.WriteLine("Total Invalid GB-PVR Programs: 0x{0:x8}", source_invalid.Count);
496              gLog.Info.WriteLine("Total GB-PVR Programs (Updated & Removed): 0x{0:x8}", source_valid.Count + source_invalid.Count);              gLog.Info.WriteLine("Total GB-PVR Programs (Valid+Invalid): 0x{0:x8} == 0x{1:x8}", source_valid.Count + source_invalid.Count, gbpvr_programs.Count);
497                #region old-code
498                //List<OldNewProgram> source_update = new List<OldNewProgram>();
499                ////if (range == null)
500                ////{
501                ////    gLog.Warn.WriteLine("The DateTimeRange passed in is null...returning the original program list");
502                ////    return list;
503                ////}
504                ////gLog.Warn.WriteLine("FilterProgramsByDateRange has not been implemented");            
505                //double total = gbpvr_programs.Count;
506                //double index = 0;
507                //double progress = 0;
508                //foreach (var program in gbpvr_programs)
509                //{  
510                //    progress = 100.0 * (index / total);
511                //    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Filtering GBPVR Programs: {0:00}%", (int)progress)));                
512                //    var channel_oid = program.channel_oid;
513                //    var channel = this.Channels.Find(s => s.oid == channel_oid);
514                //    var start_date = program.start_time;
515                //    //var xmltv_entry_list = xmltv_programs.FindAll(s => s.ChannelNumber == channel.channel_number && s.Start == start_date.ToDateTimeString());
516                //    var query = from c in xmltv_programs
517                //                where
518                //                c.ChannelNumber == channel.channel_number &&
519                //                c.Start == start_date.ToDateTimeString()
520                //                select c;
521                //    IProgramDefinition xmltv_entry = null;
522                //    if (query.Count()-1 > 0)
523                //    {
524                //        gLog.Verbose.Error.WriteLine("Found more than one entry: Matching channel='{0}' and start='{1}'", channel.channel_number, start_date.ToDateTimeString());
525                //        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);
526                //        if (Debugger.IsAttached)
527                //        {                      
528                //            gLog.Error.WriteLine("    Found: {0} matching entries", query.Count());
529                //            int k_index = 0;
530                //            foreach (var k in query)
531                //            {
532                //                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);
533                //                k_index++;
534                //            }
535                //            Debugger.Break();
536                //        }
537                //    }
538                //    else
539                //    {
540                //        xmltv_entry = query.FirstOrDefault();
541                //    }
542                //    if (xmltv_entry == null)
543                //    {
544                //        //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());
545                //        source_invalid.Add(program);                  
546                //    }
547                //    else
548                //    {
549                //        //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());
550                //        var updated_program = program;
551                //        bool needsupdate = false;
552                //        if (xmltv_entry.Title != program.name)
553                //        {
554                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
555                //            //gLog.Verbose.Warn.WriteLine("        Old Title: {0}", program.name);
556                //            //gLog.Verbose.Warn.WriteLine("        New Title: {0}", xmltv_entry.Title);
557                //            updated_program.name = xmltv_entry.Title;
558                //            needsupdate = true;
559                //        }
560                //        if (xmltv_entry.SubTitle != program.sub_title)
561                //        {
562                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
563                //            //gLog.Verbose.Warn.WriteLine("        Old SubTile: {0}", program.sub_title);
564                //            //gLog.Verbose.Warn.WriteLine("        New SubTile: {0}", xmltv_entry.SubTitle);
565                //            updated_program.sub_title = xmltv_entry.SubTitle;
566                //            needsupdate = true;
567                //        }
568                //        if (xmltv_entry.Description != program.description)
569                //        {
570                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
571                //            //gLog.Verbose.Warn.WriteLine("        Old Descption: {0}", program.description);
572                //            //gLog.Verbose.Warn.WriteLine("        New Descption: {0}", xmltv_entry.Description);
573                //            updated_program.description = xmltv_entry.Description;
574                //            needsupdate = true;
575                //        }
576                //        if (DateTime.Parse(xmltv_entry.Start) != program.start_time)
577                //        {
578                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
579                //            //gLog.Verbose.Warn.WriteLine("        Old StartTime: {0}", program.start_time.ToDateTimeString());
580                //            //gLog.Verbose.Warn.WriteLine("        New StartTime: {0}", DateTime.Parse(xmltv_entry.Start).ToDateTimeString());
581                //            updated_program.start_time = DateTime.Parse(xmltv_entry.Start);
582                //            needsupdate = true;
583                //        }
584                //        if (DateTime.Parse(xmltv_entry.Stop) != program.end_time)
585                //        {
586                //            //gLog.Verbose.Warn.WriteLine("    Updating:");
587                //            //gLog.Verbose.Warn.WriteLine("        Old EndTime: {0}", program.end_time.ToDateTimeString());
588                //            //gLog.Verbose.Warn.WriteLine("        New EndTime: {0}", DateTime.Parse(xmltv_entry.Stop).ToDateTimeString());
589                //            updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);
590                //            needsupdate = true;
591                //        }                    
592                //        if (needsupdate)
593                //        {
594                //            OldNewProgram p = new OldNewProgram();
595                //            p.OldProgram = program;
596                //            p.NewProgram = updated_program;
597                //            source_update.Add(p);
598                //        }
599                //        source_valid.Add(updated_program);
600                //    }
601                //    index++;
602                //}
603                //source_valid = source_valid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();
604                //source_invalid = source_invalid.OrderBy(s => s.channel_oid).ThenBy(s => s.start_time).ToList();
605                //if (source_invalid.Count > 0)
606                //{
607                //    double source_invalid_count = source_valid.Count;
608                //    double source_invalid_index = 0;
609                //    double source_invalid_progress = 0;
610                //    foreach (var old_program in source_invalid)
611                //    {
612                //        source_invalid_progress = 100.0 * (source_invalid_index / source_invalid_count);
613                //        gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_invalid_progress, string.Format("Removing old GBPVR Programs: {0:00}%", (int)source_invalid_progress)));    
614                //        // remove database entry
615                //        if (!RemoveProgramDatabaseEntry(old_program))
616                //        {
617                //            gLog.Error.WriteLine("Failed to remove program with oid: '{0}'", old_program.oid);
618                //        }
619                //        else
620                //        {
621                //            gLog.Verbose.Info.WriteLine("Removed program with oid: '{0}'", old_program.oid);
622                //        }
623                //        source_invalid_index++;
624                //    }
625                //}
626                //else
627                //{
628                //    gLog.Info.WriteLine("No old GB-PVR Programs needed to be removed.");
629                //}
630                //if (source_update.Count > 0)
631                //{
632                //    double source_update_count = source_valid.Count;
633                //    double source_update_index = 0;
634                //    double source_update_progress = 0;
635                //    foreach (var p in source_update)
636                //    {
637                //        source_update_progress = 100.0 * (source_update_index / source_update_count);
638                //        gLog.ReportProgress(this, new ReportProgressEventArgs((int)source_update_progress, string.Format("Updating GBPVR Programs: {0:00}%", (int)source_update_progress)));    
639                //        // remove database entry
640                //        if (!UpdateProgramDatabaseEntry(p.OldProgram,p.NewProgram))
641                //        {
642                //            gLog.Error.WriteLine("Failed to update program with oid: '{0}'", p.OldProgram.oid);
643                //        }
644                //        else
645                //        {
646                //            gLog.Verbose.Info.WriteLine("Upated program with oid: '{0}'", p.OldProgram.oid);
647                //        }
648                //        source_update_index++;
649                //    }
650                //}
651                //else
652                //{
653                //    gLog.Info.WriteLine("No GB-PVR Programs needed to be updated.");
654                //}
655                //gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);
656                //gLog.Info.WriteLine("Updated: 0x{0:x8} GB-PVR Programs", source_valid.Count);
657                //gLog.Info.WriteLine("Removed: 0x{0:x8} GB-PVR Programs", source_invalid.Count);
658                //gLog.Info.WriteLine("Total GB-PVR Programs (Updated & Removed): 0x{0:x8}", source_valid.Count + source_invalid.Count);
659                #endregion
660    
661              return source_valid;              return source_valid;
662          }          }
# Line 543  namespace GBPVRProgramDatabaseFixer Line 726  namespace GBPVRProgramDatabaseFixer
726                  gLog.Info.WriteLine("\tDestination: {0}", backup_file);                  gLog.Info.WriteLine("\tDestination: {0}", backup_file);
727    
728                  System.IO.File.Copy(this.Database, backup_file);                  System.IO.File.Copy(this.Database, backup_file);
729                    DATABASE_BACKUP_FILE = backup_file;
730                  return true;                  return true;
731              }              }
732              catch (Exception ex)              catch (Exception ex)
# Line 558  namespace GBPVRProgramDatabaseFixer Line 742  namespace GBPVRProgramDatabaseFixer
742                  List<ICHANNEL> channels = new List<ICHANNEL>();                  List<ICHANNEL> channels = new List<ICHANNEL>();
743                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
744                  {                  {
745                      con.Open();                      try
                     string command_text = string.Format("select * from {0};", TABLES.CHANNEL);  
                     gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);  
                     using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))  
746                      {                      {
747                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
748                            string command_text = string.Format("select * from {0};", TABLES.CHANNEL);
749                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
750                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
751                          {                          {
752                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
753                              {                              {
754                                  while (r.Read())                                  if (!r.HasRows)
755                                  {                                  {
756                                      CHANNEL channel = new CHANNEL();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
757                                      for (int i = 0; i < r.FieldCount; i++)                                  }
758                                    else
759                                    {
760                                        while (r.Read())
761                                      {                                      {
762                                          CHANNEL.Create(ref channel, r, i);                                          CHANNEL channel = new CHANNEL();
763                                            for (int i = 0; i < r.FieldCount; i++)
764                                            {
765                                                CHANNEL.Create(ref channel, r, i);
766                                            }
767                                            channels.Add(channel);
768                                      }                                      }
                                     channels.Add(channel);  
769                                  }                                  }
770                              }                              }
771                          }                          }
772                      }                      }
773                      con.Clone();                      catch (SQLiteException ex)
774                        {
775                            gLog.Error.WriteLine(ex.ToString());
776                        }
777                        finally
778                        {
779                            con.Close();
780                        }
781                  }                  }
782                  this.Channels = channels;                  this.Channels = channels;
783              }              }
# Line 599  namespace GBPVRProgramDatabaseFixer Line 793  namespace GBPVRProgramDatabaseFixer
793                  List<IPROGRAMME> programs = new List<IPROGRAMME>();                  List<IPROGRAMME> programs = new List<IPROGRAMME>();
794                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
795                  {                  {
796                      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))  
797                      {                      {
798                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
799                            string command_text = string.Format("select * from {0};", TABLES.PROGRAMME);
800                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
801                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
802                          {                          {
803                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
804                              {                              {
805                                  while (r.Read())                                  if (!r.HasRows)
806                                  {                                  {
807                                      PROGRAMME program = new PROGRAMME();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
808                                      for (int i = 0; i < r.FieldCount; i++)                                  }
809                                    else
810                                    {
811                                        while (r.Read())
812                                      {                                      {
813                                          PROGRAMME.Create(ref program, r, i);                                          PROGRAMME program = new PROGRAMME();
814                                            for (int i = 0; i < r.FieldCount; i++)
815                                            {
816                                                PROGRAMME.Create(ref program, r, i);
817                                            }
818                                            programs.Add(program);
819                                      }                                      }
                                     programs.Add(program);  
820                                  }                                  }
821                              }                              }
822                          }                          }
823                      }                      }
824                      con.Clone();                      catch (SQLiteException ex)
825                        {
826                            gLog.Error.WriteLine(ex.ToString());
827                        }
828                        finally
829                        {
830                            con.Close();
831                        }
832                  }                  }
833                  this.Programs = programs;                  this.Programs = programs;
834              }              }
# Line 640  namespace GBPVRProgramDatabaseFixer Line 844  namespace GBPVRProgramDatabaseFixer
844                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();
845                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
846                  {                  {
847                      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))  
848                      {                      {
849                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
850                            string command_text = string.Format("select * from {0};", TABLES.RECORDING_SCHEDULE);
851                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
852                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
853                          {                          {
854                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
855                              {                              {
856                                  while (r.Read())                                  if (!r.HasRows)
857                                  {                                  {
858                                      RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
859                                      for (int i = 0; i < r.FieldCount; i++)                                  }
860                                    else
861                                    {
862                                        while (r.Read())
863                                      {                                      {
864                                          RECORDING_SCHEDULE.Create(ref recording, r, i);                                          RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();
865                                            for (int i = 0; i < r.FieldCount; i++)
866                                            {
867                                                RECORDING_SCHEDULE.Create(ref recording, r, i);
868                                            }
869                                            recordings.Add(recording);
870                                      }                                      }
                                     recordings.Add(recording);  
871                                  }                                  }
872                              }                              }
873                          }                          }
874                      }                      }
875                      con.Clone();                      catch (SQLiteException ex)
876                        {
877                            gLog.Error.WriteLine(ex.ToString());
878                        }
879                        finally
880                        {
881                            con.Close();
882                        }
883                  }                  }
884                  this.Recordings = recordings;                  this.Recordings = recordings;
885              }              }
# Line 675  namespace GBPVRProgramDatabaseFixer Line 889  namespace GBPVRProgramDatabaseFixer
889              }              }
890          }          }
891    
892            public void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs)
893            {            
894                gLog.Info.WriteLine("Removing {0} gbpvr programs.", programs.Count);
895                int ChunkSize = 1024;
896                var ChunkList = programs.Chunk<IPROGRAMME>(ChunkSize);
897                double total = programs.Count;
898                double index = 0;
899                double progress = 0;
900                Stopwatch st1 = new Stopwatch();
901                st1.Start();
902                foreach (var p in ChunkList)
903                {
904                    progress = 100.0 * (index / total);
905                    if (!RemoveProgramDatabaseEntry(p))
906                    {
907                        gLog.Error.WriteLine("Failed to remove one or more program(s)");
908                    }
909                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Removing old gbpvr programs ({0} of {1}) {2:00}%", index, total, (int)progress)));
910                    index += (double)p.Count();
911                }
912                gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Removing old gbpvr programs ({0} of {1}) {2:00}%", index, total, (int)progress)));
913                st1.Stop();
914                gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds overall", st1.Elapsed.TotalSeconds);
915            }
916            public void UpdateGBPVRPrograms(List<IOldNewProgram> programs)
917            {
918                gLog.Info.WriteLine("Updating {0} gbpvr programs.", programs.Count);
919                int ChunkSize = 4096;
920                var ChunkList = programs.Chunk<IOldNewProgram>(ChunkSize);
921    
922                double total = programs.Count;
923                double index = 0;
924                double progress = 0;
925                Stopwatch st1 = new Stopwatch();
926                st1.Start();
927                foreach (var p in ChunkList)
928                {
929                    progress = 100.0 * (index / total);
930                    if (!UpdateProgramEntryDatabase(p))
931                    {
932                        gLog.Error.WriteLine("Failed to update one or more program(s)");
933                    }
934                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Updating gbpvr programs ({0} of {1}) {2:00}%", index, total, (int)progress)));
935                    index += (double)p.Count();                
936                }
937                gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Updating gbpvr programs ({0} of {1}) {2:00}%", index, total, (int)progress)));
938                st1.Stop();
939                gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds overall", st1.Elapsed.TotalSeconds);
940            }
941    
942          private bool RemoveProgramDatabaseEntry(IPROGRAMME old_program)          private bool RemoveAllProgramDatabaseEntries()
943          {          {
944              bool result = false;              bool result = false;
945              try              try
946              {                              {
947                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
948                  {                  {
949                      try                      try
950                      {                      {
951                          gLog.Verbose.Info.WriteLine("Removing old program with oid: '{0}'", old_program.oid);                          //gLog.Verbose.Info.WriteLine("Removing old program with oid: '{0}'", old_program.oid);
952                          con.Open();                          con.Open();
953                          string command_text = string.Format(@"DELETE FROM [{0}] WHERE [oid] = @oid;", TABLES.PROGRAMME);                          string command_text = string.Format(@"DELETE FROM [{0}];", TABLES.PROGRAMME);
954                          gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);                          //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
955                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
956                          {                          {
957                              cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));                              //cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));
958                              int rowsupdated = cmd.ExecuteNonQuery();                              int rowsupdated = cmd.ExecuteNonQuery();
959                              gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);                              //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
960                          }                          }
                         con.Clone();  
961                          result = true;                          result = true;
962                      }                      }
963                      catch (SQLiteException ex)                      catch (SQLiteException ex)
# Line 704  namespace GBPVRProgramDatabaseFixer Line 965  namespace GBPVRProgramDatabaseFixer
965                          gLog.Error.WriteLine(ex.ToString());                          gLog.Error.WriteLine(ex.ToString());
966                          result = false;                          result = false;
967                      }                      }
968                        finally
969                        {
970                            con.Close();
971                        }
972                  }                  }
973              }              }
974              catch (Exception ex)              catch (Exception ex)
# Line 713  namespace GBPVRProgramDatabaseFixer Line 978  namespace GBPVRProgramDatabaseFixer
978              }              }
979              return result;              return result;
980          }          }
981          private bool UpdateProgramDatabaseEntry(IPROGRAMME old_program, IPROGRAMME new_program)          private bool RemoveProgramDatabaseEntry(IEnumerable<IPROGRAMME> list)
982          {          {
983              bool result = false;              bool result = false;
984              try              try
# Line 722  namespace GBPVRProgramDatabaseFixer Line 987  namespace GBPVRProgramDatabaseFixer
987                  {                  {
988                      try                      try
989                      {                      {
990                          gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", old_program.oid);                          //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
991                          con.Open();                          con.Open();
992                          //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);                          //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
993                          string command_text = string.Empty;                          string command_text = string.Empty;
994                          StringBuilder builder = new StringBuilder();                          command_text = BuildGBPVRMultiDeleteCommand(list);
995                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
996                          builder.AppendLine(string.Format("UPDATE [{0}]", TABLES.PROGRAMME));                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
997                          builder.Append("SET ");                          {
998                          builder.AppendFormat("[name]=@name,");                              int rowsupdated = cmd.ExecuteNonQuery();
999                          builder.AppendFormat("[sub_title]=@sub_title,");                              //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
1000                          builder.AppendFormat("[description]=@description,");                          }
                         builder.AppendFormat("[start_time]=@start_time,");  
                         builder.AppendFormat("[end_time]=@end_time,");  
                         builder.AppendFormat("[channel_oid]=@channel_oid,");  
                         builder.AppendFormat("[unique_identifier]=@unique_identifier,");  
                         builder.AppendFormat("[rating]=@rating");  
                         builder.AppendLine(" WHERE [oid] = @oid");  
1001    
1002                          command_text = builder.ToString();                          result = true;
1003                          gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);                      }
1004                        catch (SQLiteException ex)
1005                        {
1006                            gLog.Error.WriteLine(ex.ToString());
1007                            result = false;
1008                        }
1009                        finally
1010                        {
1011                            con.Close();
1012                        }
1013                    }
1014                }
1015                catch (Exception ex)
1016                {
1017                    gLog.Error.WriteLine(ex.ToString());
1018                    result = false;
1019                }
1020                return result;
1021            }
1022            private bool UpdateProgramEntryDatabase(IEnumerable<IOldNewProgram> list)
1023            {
1024                bool result = false;
1025                try
1026                {
1027                    using (SQLiteConnection con = CreateConnection())
1028                    {
1029                        try
1030                        {
1031                            //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
1032                            con.Open();
1033                            //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
1034                            string command_text = string.Empty;
1035                            command_text = BuildGBPVRMultiUpdateCommand(list);
1036                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
1037                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
1038                          {                          {
                             cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));  
                             cmd.Parameters.Add(new SQLiteParameter("name", new_program.name));  
                             cmd.Parameters.Add(new SQLiteParameter("sub_title", new_program.sub_title));  
                             cmd.Parameters.Add(new SQLiteParameter("description", new_program.description));  
                             cmd.Parameters.Add(new SQLiteParameter("start_time", new_program.start_time));  
                             cmd.Parameters.Add(new SQLiteParameter("end_time", new_program.end_time));  
                             cmd.Parameters.Add(new SQLiteParameter("channel_oid", new_program.channel_oid));  
                             cmd.Parameters.Add(new SQLiteParameter("unique_identifier", new_program.unique_identifier));  
                             cmd.Parameters.Add(new SQLiteParameter("rating", new_program.rating));  
1039                              int rowsupdated = cmd.ExecuteNonQuery();                              int rowsupdated = cmd.ExecuteNonQuery();
1040                              gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);                              //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
1041                            }
1042    
1043                            result = true;
1044                        }
1045                        catch (SQLiteException ex)
1046                        {
1047                            gLog.Error.WriteLine(ex.ToString());
1048                            result = false;
1049                        }
1050                        finally
1051                        {
1052                            con.Close();
1053                        }
1054                    }
1055                }
1056                catch (Exception ex)
1057                {
1058                    gLog.Error.WriteLine(ex.ToString());
1059                    result = false;
1060                }
1061                return result;
1062            }
1063            private bool InsertProgramEntryDatabase(IEnumerable<IPROGRAMME> list)
1064            {
1065                bool result = false;
1066                try
1067                {
1068                    using (SQLiteConnection con = CreateConnection())
1069                    {
1070                        try
1071                        {
1072                            //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
1073                            con.Open();
1074                            //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
1075                            string command_text = string.Empty;
1076                            command_text = BuildGBPVRMultiInsertCommand(list);
1077                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
1078                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
1079                            {                          
1080                                int rowsupdated = cmd.ExecuteNonQuery();
1081                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
1082                          }                          }
1083                          con.Clone();  
1084                          result = true;                          result = true;
1085                      }                      }
1086                      catch (SQLiteException ex)                      catch (SQLiteException ex)
# Line 764  namespace GBPVRProgramDatabaseFixer Line 1088  namespace GBPVRProgramDatabaseFixer
1088                          gLog.Error.WriteLine(ex.ToString());                          gLog.Error.WriteLine(ex.ToString());
1089                          result = false;                          result = false;
1090                      }                      }
1091                        finally
1092                        {
1093                            con.Close();
1094                        }
1095                  }                  }
1096              }              }
1097              catch (Exception ex)              catch (Exception ex)
# Line 773  namespace GBPVRProgramDatabaseFixer Line 1101  namespace GBPVRProgramDatabaseFixer
1101              }              }
1102              return result;              return result;
1103          }          }
1104    
1105            #region Multi-Delete Command Support
1106            private string BuildGBPVRMultiDeleteCommand(IEnumerable<IPROGRAMME> list)
1107            {
1108                StringBuilder builder = new StringBuilder();
1109                /*
1110                    insert into table1 (field1,field2) values (value1,value2);
1111                    insert into table1 (field1,field2) values (value1,value2);
1112                    insert into table1 (field1,field2) values (value1,value2);
1113                    insert into table1 (field1,field2) values (value1,value2)
1114                 */
1115                builder.AppendLine("begin transaction;");
1116                foreach (var t in list)
1117                {
1118                    builder.AppendLine(BuildGBPVRSingleDeleteCommand(t));
1119                }
1120                builder.AppendLine("end transaction;");
1121                return builder.ToString();
1122            }
1123            private string BuildGBPVRSingleDeleteCommand(IPROGRAMME program)
1124            {
1125                StringBuilder builder = new StringBuilder();
1126                builder.AppendFormat("delete from {0} where oid={1};", TABLES.PROGRAMME, program.oid);
1127                return builder.ToString();
1128            }
1129            #endregion
1130            #region Multi-Update Command Support
1131            private string BuildGBPVRMultiUpdateCommand(IEnumerable<IOldNewProgram> list)
1132            {
1133                StringBuilder builder = new StringBuilder();
1134                /*
1135                    insert into table1 (field1,field2) values (value1,value2);
1136                    insert into table1 (field1,field2) values (value1,value2);
1137                    insert into table1 (field1,field2) values (value1,value2);
1138                    insert into table1 (field1,field2) values (value1,value2)
1139                 */
1140                builder.AppendLine("begin transaction;");
1141                foreach (var t in list)
1142                {
1143                    if (!t.OldProgram.Equals(t.NewProgram))
1144                    {
1145                        // only update the entry if it is different
1146                        builder.AppendLine(BuildGBPVRSingleUpdateCommand(t.NewProgram));
1147                    }                
1148                }
1149                builder.AppendLine("end transaction;");
1150                return builder.ToString();
1151            }
1152            private string BuildGBPVRSingleUpdateCommand(IPROGRAMME program)
1153            {
1154                StringBuilder builder = new StringBuilder();
1155                builder.AppendFormat("update {0} SET ", TABLES.PROGRAMME);
1156                builder.AppendFormat("name=\"{0}\", ", program.name);
1157                builder.AppendFormat("sub_title=\"{0}\", ", program.sub_title);
1158                builder.AppendFormat("description=\"{0}\", ", program.description);
1159                builder.AppendFormat("start_time='{0}', ", program.start_time.ToString("yyyy-MM-dd HH:mm:ss.fffffff"));
1160                builder.AppendFormat("end_time='{0}', ", program.end_time.ToString("yyyy-MM-dd HH:mm:ss.fffffff"));
1161                builder.AppendFormat("channel_oid={0}, ", program.channel_oid);
1162                builder.AppendFormat("unique_identifier=\"{0}\", ", program.unique_identifier);
1163                builder.AppendFormat("rating=\"{0}\" ", program.rating);
1164                builder.AppendFormat("where oid={0};", program.oid);
1165                return builder.ToString();
1166            }
1167            #endregion
1168            #region Multi-Insert Command Support
1169            private string BuildGBPVRMultiInsertCommand(IEnumerable<IPROGRAMME> list)
1170            {
1171                StringBuilder builder = new StringBuilder();
1172                /*
1173                    insert into table1 (field1,field2) values (value1,value2);
1174                    insert into table1 (field1,field2) values (value1,value2);
1175                    insert into table1 (field1,field2) values (value1,value2);
1176                    insert into table1 (field1,field2) values (value1,value2)
1177                 */
1178                builder.AppendLine("begin transaction;");
1179                foreach (var t in list)
1180                {
1181                    builder.AppendLine(BuildGBPVRSingleInsertCommand(t));
1182                }
1183                builder.AppendLine("end transaction;");
1184                return builder.ToString();
1185            }
1186            
1187            private string BuildGBPVRSingleInsertCommand(IPROGRAMME program)
1188            {
1189                StringBuilder builder = new StringBuilder();
1190                builder.AppendFormat("insert into {0} (oid,name,sub_title,description,start_time,end_time,channel_oid,unique_identifier,rating) values (", TABLES.PROGRAMME);
1191                builder.AppendFormat("{0},",program.oid);
1192                builder.AppendFormat("\"{0}\",", program.name);
1193                builder.AppendFormat("\"{0}\",", program.sub_title);
1194                builder.AppendFormat("\"{0}\",", program.description);
1195                builder.AppendFormat("'{0}',", program.start_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1196                builder.AppendFormat("'{0}',", program.end_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1197                builder.AppendFormat("{0},", program.channel_oid);
1198                builder.AppendFormat("\"{0}\",", program.unique_identifier);
1199                builder.AppendFormat("\"{0}\");", program.rating);
1200                return builder.ToString();
1201            }
1202            #endregion
1203    
1204      }      }
1205  }  }

Legend:
Removed from v.179  
changed lines
  Added in v.228

  ViewVC Help
Powered by ViewVC 1.1.22