/[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 180 by william, Sat Mar 16 17:41:52 2013 UTC revision 213 by william, Sun Mar 17 01:01:10 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 IOldNewProgram
15        {
16            SQLLITE.IPROGRAMME OldProgram { get; }
17            SQLLITE.IPROGRAMME NewProgram { get; }
18        }
19      public interface ISQLLITE      public interface ISQLLITE
20      {      {
21          List<SQLLITE.IPROGRAMME> Programs { get; }          List<SQLLITE.IPROGRAMME> Programs { get; }
# Line 19  namespace GBPVRProgramDatabaseFixer Line 24  namespace GBPVRProgramDatabaseFixer
24          IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs);          IDateTimeRange GetProgramsDateRange(List<SQLLITE.IPROGRAMME> programs);
25          List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> removed_programs);          List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> removed_programs);
26    
27            void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs);
28            void UpdateGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs);
29    
30      }      }
31      public class SQLLITE : ISQLLITE      public class SQLLITE : ISQLLITE
32      {      {
33          private class OldNewProgram          private class OldNewProgram : IOldNewProgram
34          {          {
35              public OldNewProgram() : this(new PROGRAMME(), new PROGRAMME()) { }              public OldNewProgram() : this(new PROGRAMME(), new PROGRAMME()) { }
36              public OldNewProgram(IPROGRAMME _old, IPROGRAMME _new) { OldProgram = _old; NewProgram = _new; }              public OldNewProgram(IPROGRAMME _old, IPROGRAMME _new) { OldProgram = _old; NewProgram = _new; }
# Line 48  namespace GBPVRProgramDatabaseFixer Line 56  namespace GBPVRProgramDatabaseFixer
56          }          }
57          private class CHANNEL : ICHANNEL          private class CHANNEL : ICHANNEL
58          {          {
59              public CHANNEL()              public CHANNEL()
60              {              {
61                  BaseDatabaseDefinition<CHANNEL>.CreateDefault(this);                  BaseDatabaseDefinition<CHANNEL>.CreateDefault(this);
62              }              }
63              //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); }
64    
# Line 81  namespace GBPVRProgramDatabaseFixer Line 89  namespace GBPVRProgramDatabaseFixer
89              Int64 manual_channel_oid { get; }              Int64 manual_channel_oid { get; }
90              Int64 quality_level { get; }              Int64 quality_level { get; }
91              Int64 pre_pad_minutes { get; }              Int64 pre_pad_minutes { get; }
92              Int64 post_pad_minutes { get;}              Int64 post_pad_minutes { get; }
93              Int32 priority { get; }              Int32 priority { get; }
94              String conversion_profile { get; }              String conversion_profile { get; }
95          }          }
# Line 122  namespace GBPVRProgramDatabaseFixer Line 130  namespace GBPVRProgramDatabaseFixer
130                  }                  }
131              }              }
132              public static void Create(ref T instance, SQLiteDataReader r, int index)              public static void Create(ref T instance, SQLiteDataReader r, int index)
133              {                              {
134                  string field_name = r.GetName(index);                  string field_name = r.GetName(index);
135                  Type field_type = r.GetFieldType(index);                  Type field_type = r.GetFieldType(index);
136                  object field_value = r.GetValue(index);                  object field_value = r.GetValue(index);
# Line 147  namespace GBPVRProgramDatabaseFixer Line 155  namespace GBPVRProgramDatabaseFixer
155                                  {                                  {
156                                      prop.SetValue(instance, field_value, null);                                      prop.SetValue(instance, field_value, null);
157                                  }                                  }
158                                    
159                              }                              }
160                              catch (Exception ex)                              catch (Exception ex)
161                              {                              {
162                                  throw ex;                                  throw ex;
163                              }                              }
# Line 167  namespace GBPVRProgramDatabaseFixer Line 175  namespace GBPVRProgramDatabaseFixer
175    
176          private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE          private class RECORDING_SCHEDULE : IRECORDING_SCHEDULE
177          {          {
178              public RECORDING_SCHEDULE()              public RECORDING_SCHEDULE()
179              {              {
180                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.CreateDefault(this);
181              }              }
182              //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }              //public RECORDING_SCHEDULE(SQLiteDataReader r, int index) { BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(this, r, index); }
183    
184              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)              public static void Create(ref RECORDING_SCHEDULE instance, SQLiteDataReader r, int index)
185              {              {
186                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);                  BaseDatabaseDefinition<RECORDING_SCHEDULE>.Create(ref instance, r, index);
187              }              }
188    
189              #region IRECORDING_SCHEDULE members              #region IRECORDING_SCHEDULE members
190              public Int64 oid { get; set;}              public Int64 oid { get; set; }
191              public Int64 programme_oid { get; set;}              public Int64 programme_oid { get; set; }
192              public Int64 capture_source_oid { get; set;}              public Int64 capture_source_oid { get; set; }
193              public Int16 status { get; set; }              public Int16 status { get; set; }
194              public String filename { get; set; }              public String filename { get; set; }
195              public Int64 recording_type { get;set; }              public Int64 recording_type { get; set; }
196              public Int64 recording_group { get; set;}              public Int64 recording_group { get; set; }
197              public DateTime manual_start_time { get; set;}              public DateTime manual_start_time { get; set; }
198              public DateTime manual_end_time { get; set; }              public DateTime manual_end_time { get; set; }
199              public Int64 manual_channel_oid { get; set; }              public Int64 manual_channel_oid { get; set; }
200              public Int64 quality_level { get; set; }              public Int64 quality_level { get; set; }
# Line 197  namespace GBPVRProgramDatabaseFixer Line 205  namespace GBPVRProgramDatabaseFixer
205              #endregion              #endregion
206          }          }
207    
208          public interface IPROGRAMME          public interface IPROGRAMME : IEquatable<IPROGRAMME>
209          {          {
210              Int64 oid { get; set; }              Int64 oid { get; set; }
211              String name { get; set; }              String name { get; set; }
# Line 209  namespace GBPVRProgramDatabaseFixer Line 217  namespace GBPVRProgramDatabaseFixer
217              String unique_identifier { get; set; }              String unique_identifier { get; set; }
218              String rating { get; set; }              String rating { get; set; }
219    
220                string ToString();
221              IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite);              IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite);
222          }          }
223          private class PROGRAMME : IPROGRAMME          private class PROGRAMME : IPROGRAMME
224          {          {
225              public PROGRAMME()              public PROGRAMME()
226              {              {
227                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);                  BaseDatabaseDefinition<PROGRAMME>.CreateDefault(this);
228              }              }
229              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }              //public PROGRAMME(SQLiteDataReader r, int index) : base(r, index) { }
230              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)              public static void Create(ref PROGRAMME instance, SQLiteDataReader r, int index)
# Line 235  namespace GBPVRProgramDatabaseFixer Line 244  namespace GBPVRProgramDatabaseFixer
244              public IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite)              public IProgramDefinition AsXMLTVProgramDefinition(ISQLLITE sqllite)
245              {              {
246                  ProgramList.ProgramDefintion definition = new ProgramList.ProgramDefintion();                  ProgramList.ProgramDefintion definition = new ProgramList.ProgramDefintion();
247    
248                  var channel = sqllite.Channels.Find(s => s.oid == this.channel_oid);                  var channel = sqllite.Channels.Find(s => s.oid == this.channel_oid);
249                  definition.ChannelName = channel.display_name;                  var channelname = channel.display_name;
250                  definition.ChannelNumber = (int)channel.channel_number;                  var split = channelname.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
251                    definition.ChannelNumber = Convert.ToInt32(split.First());
252                    definition.ChannelName = string.IsNullOrEmpty(split.Last()) ? string.Empty : split.Last().ToString();
253                  definition.Description = this.description;                  definition.Description = this.description;
254                  definition.Start = this.start_time.ToDateTimeString();                  definition.Start = this.start_time.ToDateTimeString();
255                  definition.Stop = this.end_time.ToDateTimeString();                  definition.Stop = this.end_time.ToDateTimeString();
# Line 246  namespace GBPVRProgramDatabaseFixer Line 258  namespace GBPVRProgramDatabaseFixer
258                  return definition;                  return definition;
259              }              }
260              #endregion              #endregion
261    
262                public bool Equals(IPROGRAMME other)
263                {
264                    return this.ToString() == other.ToString();
265                }
266                public override string ToString()
267                {
268                    StringBuilder builder = new StringBuilder();
269    
270                    builder.AppendFormat("oid: '{0}' ", oid);
271                    builder.AppendFormat("name: '{0}' ", name);
272                    builder.AppendFormat("sub_title: '{0}' ", sub_title);
273                    builder.AppendFormat("description: '{0}' ", description);
274                    builder.AppendFormat("start_time: '{0}' ", start_time.ToDateTimeString());
275                    builder.AppendFormat("end_time: '{0}' ", end_time.ToDateTimeString());
276                    builder.AppendFormat("channel_oid: '{0}' ", channel_oid);
277                    builder.AppendFormat("unique_identifier: '{0}' ", unique_identifier);
278                    builder.AppendFormat("rating: '{0}'", rating);
279    
280                    return builder.ToString();
281                }
282                public override bool Equals(object obj)
283                {
284                    if (obj == null) { throw new ArgumentNullException("obj", "Object to compare cannot be null"); }
285                    if (obj.GetType().IsAssignableFrom(typeof(IPROGRAMME)))
286                    {
287                        return this.Equals((IPROGRAMME)obj);
288                    }
289                    return base.Equals(obj);
290                }
291                public override int GetHashCode()
292                {
293                    return this.ToString().GetHashCode();
294                }
295          }          }
296          #endregion          #endregion
297          private static class TABLES          private static class TABLES
# Line 254  namespace GBPVRProgramDatabaseFixer Line 300  namespace GBPVRProgramDatabaseFixer
300              public const string PROGRAMME = "PROGRAMME";              public const string PROGRAMME = "PROGRAMME";
301              public const string CHANNEL = "CHANNEL";              public const string CHANNEL = "CHANNEL";
302          }          }
303            private string DATABASE_BACKUP_FILE = string.Empty;
304          //public SQLLite() { }          //public SQLLite() { }
305          protected SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)          protected SQLLITE(string database, EventHandler<EventArgs> OnInstanceCreated)
306          {          {
307              this.OnInstanceCreated = OnInstanceCreated;              this.OnInstanceCreated = OnInstanceCreated;
308              //CreateConnection(database);              //CreateConnection(database);
# Line 276  namespace GBPVRProgramDatabaseFixer Line 322  namespace GBPVRProgramDatabaseFixer
322          [NonSerialized]          [NonSerialized]
323          private EventHandler<EventArgs> _OnInstanceCreated;          private EventHandler<EventArgs> _OnInstanceCreated;
324          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }          private EventHandler<EventArgs> OnInstanceCreated { get { return _OnInstanceCreated; } set { _OnInstanceCreated = value; } }
325            
326          private void OnCreatedInstance(object sender, EventArgs e)          private void OnCreatedInstance(object sender, EventArgs e)
327          {          {
328              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }              if (OnInstanceCreated != null) { OnInstanceCreated.Invoke(sender, e); }
329          }          }
330    
331          private string Database;          private string Database;
332          #region ISQLLITE members                  #region ISQLLITE members
333          public List<IPROGRAMME> Programs { get; private set; }          public List<IPROGRAMME> Programs { get; private set; }
334          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }          public List<IRECORDING_SCHEDULE> Recordings { get; private set; }
335          public List<ICHANNEL> Channels { get; private set; }          public List<ICHANNEL> Channels { get; private set; }
# Line 293  namespace GBPVRProgramDatabaseFixer Line 339  namespace GBPVRProgramDatabaseFixer
339              var list = new List<IPROGRAMME>(programs.ToArray());              var list = new List<IPROGRAMME>(programs.ToArray());
340              DateTime first = new DateTime();              DateTime first = new DateTime();
341              DateTime last = new DateTime();              DateTime last = new DateTime();
342              first = list.OrderBy(s => s.start_time).ToList().First().start_time;                          first = list.OrderBy(s => s.start_time).ToList().First().start_time;
343              last = list.OrderBy(s => s.start_time).ToList().Last().start_time;              last = list.OrderBy(s => s.start_time).ToList().Last().start_time;
344              gLog.Verbose.Debug.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());              gLog.Verbose.Debug.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
345              gLog.Verbose.Debug.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());              gLog.Verbose.Debug.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
# Line 304  namespace GBPVRProgramDatabaseFixer Line 350  namespace GBPVRProgramDatabaseFixer
350          public List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> source_invalid)          public List<SQLLITE.IPROGRAMME> FixGBPVRProgramsDatabase(List<SQLLITE.IPROGRAMME> gbpvr_programs, List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs, out List<SQLLITE.IPROGRAMME> source_invalid)
351          {          {
352              source_invalid = new List<IPROGRAMME>();              source_invalid = new List<IPROGRAMME>();
353              List<SQLLITE.IPROGRAMME> source_valid = new List<IPROGRAMME>();              List<IPROGRAMME> source_valid = new List<IPROGRAMME>();
354              gbpvr_programs = gbpvr_programs.OrderBy(s => s.start_time).ToList();              gbpvr_programs = gbpvr_programs.OrderBy(s => s.start_time).ToList();
355              xmltv_programs = xmltv_programs.OrderBy(s => DateTime.Parse(s.Start)).ToList();              xmltv_programs = xmltv_programs.OrderBy(s => DateTime.Parse(s.Start)).ToList();
356              gbpvr_programs.TrimExcess();              gbpvr_programs.TrimExcess();
# Line 316  namespace GBPVRProgramDatabaseFixer Line 362  namespace GBPVRProgramDatabaseFixer
362              foreach (var program in gbpvr_programs)              foreach (var program in gbpvr_programs)
363              {              {
364                  progress = 100.0 * (index / total);                  progress = 100.0 * (index / total);
365                  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)));
366                  // find an entry in xmltv_programs by Channel Number & StartDate                                  // find an entry in xmltv_programs by Channel Number & StartDate                
367                  var program_xmltv_entry = program.AsXMLTVProgramDefinition(this);                  var program_xmltv_entry = program.AsXMLTVProgramDefinition(this);
368                  var xmltv_entry = xmltv_programs.Find(s => s.ChannelNumber == program_xmltv_entry.ChannelNumber && s.Start == program_xmltv_entry.Start);                  var xmltv_entry = xmltv_programs.Find(s => s.ChannelNumber == program_xmltv_entry.ChannelNumber && s.Start == program_xmltv_entry.Start);
# Line 328  namespace GBPVRProgramDatabaseFixer Line 374  namespace GBPVRProgramDatabaseFixer
374                  else                  else
375                  {                  {
376                      // check if the xmltv entry has different data from the current program                      // check if the xmltv entry has different data from the current program
377                      if(!xmltv_entry.Equals(program_xmltv_entry))                      if (!xmltv_entry.Equals(program_xmltv_entry))
378                      {                      {
379                          // data is different                          // data is different
380                          if (Debugger.IsAttached)                          var updated_program = program;
381    
382                            if (program_xmltv_entry.Title != xmltv_entry.Title)
383                            {
384                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing title", updated_program.oid);
385                                updated_program.name = xmltv_entry.Title;
386                            }
387                            if (program_xmltv_entry.SubTitle != xmltv_entry.SubTitle)
388                            {
389                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing sub_title", updated_program.oid);
390                                updated_program.sub_title = xmltv_entry.SubTitle;
391                            }
392                            if (program_xmltv_entry.Stop != xmltv_entry.Stop)
393                            {
394                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing end_time", updated_program.oid);
395                                updated_program.end_time = DateTime.Parse(xmltv_entry.Stop);
396                            }
397                            if (program_xmltv_entry.Start != xmltv_entry.Start)
398                            {
399                                gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing start_time", updated_program.oid);
400                                updated_program.start_time = DateTime.Parse(xmltv_entry.Start);
401                            }
402                            if (program_xmltv_entry.Description != xmltv_entry.Description)
403                          {                          {
404                              Debugger.Break();                              gLog.Verbose.Warn.WriteLine("    Program oid: '{0}' - replacing description", updated_program.oid);
405                                updated_program.description = xmltv_entry.Description;
406                          }                          }
407    
408                            var updated_xmltv_entry = updated_program.AsXMLTVProgramDefinition(this);
409                            if (!xmltv_entry.Equals(updated_xmltv_entry))
410                            {
411                                throw new Exception(string.Format("Program oid '{0}' was not properly updated.", updated_program.oid));
412                            }
413                            //source_valid.Add(new OldNewProgram(program, updated_program));
414                            source_valid.Add(updated_program);
415                      }                      }
416                      else                      else
417                      {                      {
418                          // data is the same                          // data is the same
419                          if (Debugger.IsAttached)                          //source_valid.Add(new OldNewProgram(program, program));
420                          {                          source_valid.Add(program);
                             Debugger.Break();  
                         }  
421                      }                      }
422                  }                  }
423                    index++;
424              }              }
425                gLog.Info.WriteLine("Total XMLTV Programs: 0x{0:x8}", xmltv_programs.Count);
426                gLog.Info.WriteLine("Total Valid GB-PVR Programs: 0x{0:x8}", source_valid.Count);
427                gLog.Info.WriteLine("Total Invalid GB-PVR Programs: 0x{0:x8}", source_invalid.Count);
428                gLog.Info.WriteLine("Total GB-PVR Programs (Valid+Invalid): 0x{0:x8} == 0x{1:x8}", source_valid.Count + source_invalid.Count, gbpvr_programs.Count);
429              #region old-code              #region old-code
430              //List<OldNewProgram> source_update = new List<OldNewProgram>();              //List<OldNewProgram> source_update = new List<OldNewProgram>();
431              ////if (range == null)              ////if (range == null)
# Line 579  namespace GBPVRProgramDatabaseFixer Line 658  namespace GBPVRProgramDatabaseFixer
658                  gLog.Info.WriteLine("\tDestination: {0}", backup_file);                  gLog.Info.WriteLine("\tDestination: {0}", backup_file);
659    
660                  System.IO.File.Copy(this.Database, backup_file);                  System.IO.File.Copy(this.Database, backup_file);
661                    DATABASE_BACKUP_FILE = backup_file;
662                  return true;                  return true;
663              }              }
664              catch (Exception ex)              catch (Exception ex)
# Line 594  namespace GBPVRProgramDatabaseFixer Line 674  namespace GBPVRProgramDatabaseFixer
674                  List<ICHANNEL> channels = new List<ICHANNEL>();                  List<ICHANNEL> channels = new List<ICHANNEL>();
675                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
676                  {                  {
677                      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))  
678                      {                      {
679                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
680                            string command_text = string.Format("select * from {0};", TABLES.CHANNEL);
681                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
682                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
683                          {                          {
684                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
685                              {                              {
686                                  while (r.Read())                                  if (!r.HasRows)
687                                  {                                  {
688                                      CHANNEL channel = new CHANNEL();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
689                                      for (int i = 0; i < r.FieldCount; i++)                                  }
690                                    else
691                                    {
692                                        while (r.Read())
693                                      {                                      {
694                                          CHANNEL.Create(ref channel, r, i);                                          CHANNEL channel = new CHANNEL();
695                                            for (int i = 0; i < r.FieldCount; i++)
696                                            {
697                                                CHANNEL.Create(ref channel, r, i);
698                                            }
699                                            channels.Add(channel);
700                                      }                                      }
                                     channels.Add(channel);  
701                                  }                                  }
702                              }                              }
703                          }                          }
704                      }                      }
705                      con.Clone();                      catch (SQLiteException ex)
706                        {
707                            gLog.Error.WriteLine(ex.ToString());
708                        }
709                        finally
710                        {
711                            con.Close();
712                        }
713                  }                  }
714                  this.Channels = channels;                  this.Channels = channels;
715              }              }
# Line 635  namespace GBPVRProgramDatabaseFixer Line 725  namespace GBPVRProgramDatabaseFixer
725                  List<IPROGRAMME> programs = new List<IPROGRAMME>();                  List<IPROGRAMME> programs = new List<IPROGRAMME>();
726                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
727                  {                  {
728                      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))  
729                      {                      {
730                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
731                            string command_text = string.Format("select * from {0};", TABLES.PROGRAMME);
732                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
733                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
734                          {                          {
735                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
736                              {                              {
737                                  gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);                                  if (!r.HasRows)
                             }  
                             else  
                             {  
                                 while (r.Read())  
738                                  {                                  {
739                                      PROGRAMME program = new PROGRAMME();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
740                                      for (int i = 0; i < r.FieldCount; i++)                                  }
741                                    else
742                                    {
743                                        while (r.Read())
744                                      {                                      {
745                                          PROGRAMME.Create(ref program, r, i);                                          PROGRAMME program = new PROGRAMME();
746                                            for (int i = 0; i < r.FieldCount; i++)
747                                            {
748                                                PROGRAMME.Create(ref program, r, i);
749                                            }
750                                            programs.Add(program);
751                                      }                                      }
                                     programs.Add(program);  
752                                  }                                  }
753                              }                              }
754                          }                          }
755                      }                      }
756                      con.Clone();                      catch (SQLiteException ex)
757                        {
758                            gLog.Error.WriteLine(ex.ToString());
759                        }
760                        finally
761                        {
762                            con.Close();
763                        }
764                  }                  }
765                  this.Programs = programs;                  this.Programs = programs;
766              }              }
# Line 676  namespace GBPVRProgramDatabaseFixer Line 776  namespace GBPVRProgramDatabaseFixer
776                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();                  List<IRECORDING_SCHEDULE> recordings = new List<IRECORDING_SCHEDULE>();
777                  using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
778                  {                  {
779                      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))  
780                      {                      {
781                          using (SQLiteDataReader r = cmd.ExecuteReader())                          con.Open();
782                            string command_text = string.Format("select * from {0};", TABLES.RECORDING_SCHEDULE);
783                            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
784                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
785                          {                          {
786                              if (!r.HasRows)                              using (SQLiteDataReader r = cmd.ExecuteReader())
                             {  
                                 gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);  
                             }  
                             else  
787                              {                              {
788                                  while (r.Read())                                  if (!r.HasRows)
789                                  {                                  {
790                                      RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();                                      gLog.Warn.WriteLine("Query: '{0}' returned no rows.", cmd.CommandText);
791                                      for (int i = 0; i < r.FieldCount; i++)                                  }
792                                    else
793                                    {
794                                        while (r.Read())
795                                      {                                      {
796                                          RECORDING_SCHEDULE.Create(ref recording, r, i);                                          RECORDING_SCHEDULE recording = new RECORDING_SCHEDULE();
797                                            for (int i = 0; i < r.FieldCount; i++)
798                                            {
799                                                RECORDING_SCHEDULE.Create(ref recording, r, i);
800                                            }
801                                            recordings.Add(recording);
802                                      }                                      }
                                     recordings.Add(recording);  
803                                  }                                  }
804                              }                              }
805                          }                          }
806                      }                      }
807                      con.Clone();                      catch (SQLiteException ex)
808                        {
809                            gLog.Error.WriteLine(ex.ToString());
810                        }
811                        finally
812                        {
813                            con.Close();
814                        }
815                  }                  }
816                  this.Recordings = recordings;                  this.Recordings = recordings;
817              }              }
# Line 711  namespace GBPVRProgramDatabaseFixer Line 821  namespace GBPVRProgramDatabaseFixer
821              }              }
822          }          }
823    
824            public void RemoveOldGBPVRPrograms(List<SQLLITE.IPROGRAMME> programs)
825            {            
826                //gLog.Info.WriteLine("Removing {0} gbpvr programs.", programs.Count);
827                //double total = programs.Count;
828                //double index = 0;
829                //double progress = 0;
830                //Stopwatch st = new Stopwatch();
831                //st.Start();
832                //foreach (var program in programs)
833                //{
834                //    progress = 100.0 * (index / total);
835                //    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Removing GBPVR Program ({0:00}%) oid='{1}'", (int)progress, program.oid)));
836                //    if (!RemoveProgramDatabaseEntry(program))
837                //    {
838                //        gLog.Error.WriteLine("Failed to remove program with oid: {0}", program.oid);
839                //    }
840                //    index++;
841                //}
842                ////Stopwatch st = new Stopwatch();
843                ////st.Start();
844                ////if (!RemoveAllProgramDatabaseEntries())
845                ////{
846                ////    gLog.Error.WriteLine("Failed to remove one or more program(s)");
847                ////}
848                //st.Stop();
849                //gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds", st.Elapsed.TotalSeconds);
850    
851                int ChunkSize = 1024;
852                var ChunkList = programs.Chunk<IPROGRAMME>(ChunkSize);
853    
854          private bool RemoveProgramDatabaseEntry(IPROGRAMME old_program)              double total = programs.Count;
855                double index = 0;
856                double progress = 0;
857                Stopwatch st1 = new Stopwatch();
858                st1.Start();
859                foreach (var p in ChunkList)
860                {
861                    progress = 100.0 * (index / total);
862                    if (!RemoveProgramDatabaseEntry(p))
863                    {
864                        gLog.Error.WriteLine("Failed to remove one or more program(s)");
865                    }
866                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Removing {0} gbpvr programs ({1} of {2}) {3:00}%", p.Count(), index, total, (int)progress)));
867                    index += (double)p.Count();
868                }
869                st1.Stop();
870                gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds overall", st1.Elapsed.TotalSeconds);
871            }
872            public void UpdateGBPVRPrograms(List<IPROGRAMME> programs)
873            {
874                int ChunkSize = 1024;
875                var ChunkList = programs.Chunk<IPROGRAMME>(ChunkSize);
876    
877                double total = programs.Count;
878                double index = 0;
879                double progress = 0;
880                Stopwatch st1 = new Stopwatch();
881                st1.Start();
882                foreach (var p in ChunkList)
883                {
884                    //Stopwatch st2 = new Stopwatch();
885                    //st2.Start();
886                    progress = 100.0 * (index / total);
887                    //gLog.Warn.WriteLine("Inserting {0} gbpvr programs ({1} of {2})", p.Count(), index, total);  
888                    if (!UpdateProgramEntryDatabase(p))
889                    {
890                        gLog.Error.WriteLine("Failed to update one or more program(s)");
891                    }
892                    //st2.Stop();
893                    //gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds", st2.Elapsed.TotalSeconds);
894                    //gLog.Warn.WriteLine(System.Environment.NewLine);
895                    gLog.ReportProgress(this, new ReportProgressEventArgs((int)progress, string.Format("Updating {0} gbpvr programs ({1} of {2}) {3:00}%", p.Count(), index, total, (int)progress)));
896                    index += (double)p.Count();                
897                }
898                st1.Stop();
899                gLog.Warn.WriteLine("    operation took: {0:0.00000} seconds overall", st1.Elapsed.TotalSeconds);
900            }
901    
902            private bool RemoveAllProgramDatabaseEntries()
903          {          {
904              bool result = false;              bool result = false;
905              //try              try
906              //{                              {
907              //    using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
908              //    {                  {
909              //        try                      try
910              //        {                      {
911              //            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);
912              //            con.Open();                          con.Open();
913              //            string command_text = string.Format(@"DELETE FROM [{0}] WHERE [oid] = @oid;", TABLES.PROGRAMME);                          string command_text = string.Format(@"DELETE FROM [{0}];", TABLES.PROGRAMME);
914              //            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);                          //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
915              //            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
916              //            {                          {
917              //                cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));                              //cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));
918              //                int rowsupdated = cmd.ExecuteNonQuery();                              int rowsupdated = cmd.ExecuteNonQuery();
919              //                gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);                              //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
920              //            }                          }
921              //            con.Clone();                          result = true;
922              //            result = true;                      }
923              //        }                      catch (SQLiteException ex)
924              //        catch (SQLiteException ex)                      {
925              //        {                          gLog.Error.WriteLine(ex.ToString());
926              //            gLog.Error.WriteLine(ex.ToString());                          result = false;
927              //            result = false;                      }
928              //        }                      finally
929              //    }                      {
930              //}                          con.Close();
931              //catch (Exception ex)                      }
932              //{                  }
933              //    gLog.Error.WriteLine(ex.ToString());              }
934              //    result = false;              catch (Exception ex)
935              //}              {
936                    gLog.Error.WriteLine(ex.ToString());
937                    result = false;
938                }
939              return result;              return result;
940          }          }
941          private bool UpdateProgramDatabaseEntry(IPROGRAMME old_program, IPROGRAMME new_program)          private bool RemoveProgramDatabaseEntry(IEnumerable<IPROGRAMME> list)
942          {          {
943              bool result = false;              bool result = false;
944              //try              try
945              //{              {
946              //    using (SQLiteConnection con = CreateConnection())                  using (SQLiteConnection con = CreateConnection())
947              //    {                  {
948              //        try                      try
949              //        {                      {
950              //            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);
951              //            con.Open();                          con.Open();
952              //            //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);
953              //            string command_text = string.Empty;                          string command_text = string.Empty;
954              //            StringBuilder builder = new StringBuilder();                          command_text = BuildGBPVRMultiDeleteCommand(list);
955              //            builder.AppendLine(string.Format("UPDATE [{0}]", TABLES.PROGRAMME));                          //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
956              //            builder.Append("SET ");                          using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
957              //            builder.AppendFormat("[name]=@name,");                          {
958              //            builder.AppendFormat("[sub_title]=@sub_title,");                              int rowsupdated = cmd.ExecuteNonQuery();
959              //            builder.AppendFormat("[description]=@description,");                              //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
960              //            builder.AppendFormat("[start_time]=@start_time,");                          }
961              //            builder.AppendFormat("[end_time]=@end_time,");  
962              //            builder.AppendFormat("[channel_oid]=@channel_oid,");                          result = true;
963              //            builder.AppendFormat("[unique_identifier]=@unique_identifier,");                      }
964              //            builder.AppendFormat("[rating]=@rating");                      catch (SQLiteException ex)
965              //            builder.AppendLine(" WHERE [oid] = @oid");                      {
966              //            command_text = builder.ToString();                          gLog.Error.WriteLine(ex.ToString());
967              //            gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);                          result = false;
968              //            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))                      }
969              //            {                      finally
970              //                cmd.Parameters.Add(new SQLiteParameter("oid", old_program.oid));                      {
971              //                cmd.Parameters.Add(new SQLiteParameter("name", new_program.name));                          con.Close();
972              //                cmd.Parameters.Add(new SQLiteParameter("sub_title", new_program.sub_title));                      }
973              //                cmd.Parameters.Add(new SQLiteParameter("description", new_program.description));                  }
974              //                cmd.Parameters.Add(new SQLiteParameter("start_time", new_program.start_time));              }
975              //                cmd.Parameters.Add(new SQLiteParameter("end_time", new_program.end_time));              catch (Exception ex)
976              //                cmd.Parameters.Add(new SQLiteParameter("channel_oid", new_program.channel_oid));              {
977              //                cmd.Parameters.Add(new SQLiteParameter("unique_identifier", new_program.unique_identifier));                  gLog.Error.WriteLine(ex.ToString());
978              //                cmd.Parameters.Add(new SQLiteParameter("rating", new_program.rating));                  result = false;
979              //                int rowsupdated = cmd.ExecuteNonQuery();              }
             //                gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);  
             //            }  
             //            con.Clone();  
             //            result = true;  
             //        }  
             //        catch (SQLiteException ex)  
             //        {  
             //            gLog.Error.WriteLine(ex.ToString());  
             //            result = false;  
             //        }  
             //    }  
             //}  
             //catch (Exception ex)  
             //{  
             //    gLog.Error.WriteLine(ex.ToString());  
             //    result = false;  
             //}  
980              return result;              return result;
981          }          }
982            private bool UpdateProgramEntryDatabase(IEnumerable<IPROGRAMME> list)
983            {
984                bool result = false;
985                try
986                {
987                    using (SQLiteConnection con = CreateConnection())
988                    {
989                        try
990                        {
991                            //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
992                            con.Open();
993                            //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
994                            string command_text = string.Empty;
995                            command_text = BuildGBPVRMultiUpdateCommand(list);
996                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
997                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
998                            {
999                                int rowsupdated = cmd.ExecuteNonQuery();
1000                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
1001                            }
1002    
1003                            result = true;
1004                        }
1005                        catch (SQLiteException ex)
1006                        {
1007                            gLog.Error.WriteLine(ex.ToString());
1008                            result = false;
1009                        }
1010                        finally
1011                        {
1012                            con.Close();
1013                        }
1014                    }
1015                }
1016                catch (Exception ex)
1017                {
1018                    gLog.Error.WriteLine(ex.ToString());
1019                    result = false;
1020                }
1021                return result;
1022            }
1023            private bool InsertProgramEntryDatabase(IEnumerable<IPROGRAMME> list)
1024            {
1025                bool result = false;
1026                try
1027                {
1028                    using (SQLiteConnection con = CreateConnection())
1029                    {
1030                        try
1031                        {
1032                            //gLog.Verbose.Info.WriteLine("Updating old program with oid: '{0}'", new_program.oid);
1033                            con.Open();
1034                            //string command_text = string.Format(@"UPDATE [{0}] SET [name]=@name,[sub_title]=@subtitle, WHERE [OID] = @oid", TABLES.PROGRAMME);
1035                            string command_text = string.Empty;
1036                            command_text = BuildGBPVRMultiInsertCommand(list);
1037                            //gLog.Verbose.Debug.WriteLine("Executing Command: '{0}'", command_text);
1038                            using (SQLiteCommand cmd = new SQLiteCommand(command_text, con))
1039                            {                          
1040                                int rowsupdated = cmd.ExecuteNonQuery();
1041                                //gLog.Verbose.Info.WriteLine("Updated '{0}' rows", rowsupdated);
1042                            }
1043    
1044                            result = true;
1045                        }
1046                        catch (SQLiteException ex)
1047                        {
1048                            gLog.Error.WriteLine(ex.ToString());
1049                            result = false;
1050                        }
1051                        finally
1052                        {
1053                            con.Close();
1054                        }
1055                    }
1056                }
1057                catch (Exception ex)
1058                {
1059                    gLog.Error.WriteLine(ex.ToString());
1060                    result = false;
1061                }
1062                return result;
1063            }
1064    
1065            #region Multi-Delete Command Support
1066            private string BuildGBPVRMultiDeleteCommand(IEnumerable<IPROGRAMME> list)
1067            {
1068                StringBuilder builder = new StringBuilder();
1069                /*
1070                    insert into table1 (field1,field2) values (value1,value2);
1071                    insert into table1 (field1,field2) values (value1,value2);
1072                    insert into table1 (field1,field2) values (value1,value2);
1073                    insert into table1 (field1,field2) values (value1,value2)
1074                 */
1075                builder.AppendLine("begin transaction;");
1076                foreach (var t in list)
1077                {
1078                    builder.AppendLine(BuildGBPVRSingleDeleteCommand(t));
1079                }
1080                builder.AppendLine("end transaction;");
1081                return builder.ToString();
1082            }
1083            private string BuildGBPVRSingleDeleteCommand(IPROGRAMME program)
1084            {
1085                StringBuilder builder = new StringBuilder();
1086                builder.AppendFormat("delete from {0} where oid={1};", TABLES.PROGRAMME, program.oid);
1087                return builder.ToString();
1088            }
1089            #endregion
1090            #region Multi-Update Command Support
1091            private string BuildGBPVRMultiUpdateCommand(IEnumerable<IPROGRAMME> list)
1092            {
1093                StringBuilder builder = new StringBuilder();
1094                /*
1095                    insert into table1 (field1,field2) values (value1,value2);
1096                    insert into table1 (field1,field2) values (value1,value2);
1097                    insert into table1 (field1,field2) values (value1,value2);
1098                    insert into table1 (field1,field2) values (value1,value2)
1099                 */
1100                builder.AppendLine("begin transaction;");
1101                foreach (var t in list)
1102                {
1103                    builder.AppendLine(BuildGBPVRSingleInsertCommand(t));
1104                }
1105                builder.AppendLine("end transaction;");
1106                return builder.ToString();
1107            }
1108            private string BuildGBPVRSingleUpdateCommand(IPROGRAMME program)
1109            {
1110                StringBuilder builder = new StringBuilder();
1111                builder.AppendFormat("update {0} SET ", TABLES.PROGRAMME);
1112                builder.AppendFormat("name=\"{0}\", ", program.name);
1113                builder.AppendFormat("sub_title=\"{0}\", ", program.sub_title);
1114                builder.AppendFormat("description=\"{0}\", ", program.description);
1115                builder.AppendFormat("start_time='{0}', ", program.start_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1116                builder.AppendFormat("end_time='{0}', ", program.end_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1117                builder.AppendFormat("channel_oid={0}, ", program.channel_oid);
1118                builder.AppendFormat("unique_identifier=\"{0}\", ", program.unique_identifier);
1119                builder.AppendFormat("rating=\"{0}\" ", program.rating);
1120                builder.AppendFormat("where oid={0};", program.oid);
1121                return builder.ToString();
1122            }
1123            #endregion
1124            #region Multi-Insert Command Support
1125            private string BuildGBPVRMultiInsertCommand(IEnumerable<IPROGRAMME> list)
1126            {
1127                StringBuilder builder = new StringBuilder();
1128                /*
1129                    insert into table1 (field1,field2) values (value1,value2);
1130                    insert into table1 (field1,field2) values (value1,value2);
1131                    insert into table1 (field1,field2) values (value1,value2);
1132                    insert into table1 (field1,field2) values (value1,value2)
1133                 */
1134                builder.AppendLine("begin transaction;");
1135                foreach (var t in list)
1136                {
1137                    builder.AppendLine(BuildGBPVRSingleInsertCommand(t));
1138                }
1139                builder.AppendLine("end transaction;");
1140                return builder.ToString();
1141            }
1142            
1143            private string BuildGBPVRSingleInsertCommand(IPROGRAMME program)
1144            {
1145                StringBuilder builder = new StringBuilder();
1146                builder.AppendFormat("insert into {0} (oid,name,sub_title,description,start_time,end_time,channel_oid,unique_identifier,rating) values (", TABLES.PROGRAMME);
1147                builder.AppendFormat("{0},",program.oid);
1148                builder.AppendFormat("\"{0}\",", program.name);
1149                builder.AppendFormat("\"{0}\",", program.sub_title);
1150                builder.AppendFormat("\"{0}\",", program.description);
1151                builder.AppendFormat("'{0}',", program.start_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1152                builder.AppendFormat("'{0}',", program.end_time.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
1153                builder.AppendFormat("{0},", program.channel_oid);
1154                builder.AppendFormat("\"{0}\",", program.unique_identifier);
1155                builder.AppendFormat("\"{0}\");", program.rating);
1156                return builder.ToString();
1157            }
1158            #endregion
1159    
1160      }      }
1161  }  }

Legend:
Removed from v.180  
changed lines
  Added in v.213

  ViewVC Help
Powered by ViewVC 1.1.22