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

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

  ViewVC Help
Powered by ViewVC 1.1.22