rec10/trunk/src/dbMySQL.py

   1 #!/usr/bin/python
   2 # coding: UTF-8
   3 # Rec10 TS Recording Tools
   4 # Copyright (C) 2009-2010 Yukikaze
   5 import MySQLdb
   6 import recdblist
   7 import warnings
   8
   9 from decimal import Decimal
  10 class DB_MySQL:
  11     dbname = ""
  12     dbhost = ""
  13     dbusr = ""
  14     dbpasswd = ""
  15     dbport = 0
  16     def __init__(self, dbname, user, passwd, host="localhost", port=3306):
  17         warnings.filterwarnings('ignore', "Data truncated for column")
  18         self.dbname = dbname
  19         self.dbhost = host
  20         self.dbusr = user
  21         self.dbpasswd = passwd
  22         self.dbport = port
  23         try:
  24             con = MySQLdb.connect(user=user, passwd=passwd)
  25             cur = con.cursor()
  26             cur.execute('CREATE DATABASE ' + dbname + " DEFAULT CHARACTER SET utf8")
  27             cur.close()
  28             con.close()
  29         except:
  30             ""
  31         db = self.connect_db()
  32         try:
  33             db[1].execute('\
  34             CREATE TABLE timeline \
  35             (\
  36             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
  37             type VARCHAR(40),\
  38             chtxt VARCHAR(40),\
  39             title VARCHAR(100),\
  40             btime DATETIME,\
  41             etime DATETIME,\
  42             deltatime VARCHAR(5),\
  43             deltaday VARCHAR(5),\
  44             opt VARCHAR(20),\
  45             epgtitle VARCHAR(100),\
  46             epgbtime DATETIME,\
  47             epgetime DATETIME,\
  48             epgduplicate TINYINT DEFAULT 0,\
  49             epgchange TINYINT DEFAULT 0,\
  50             UNIQUE uni (type,chtxt,title,btime,deltaday)\
  51             )')
  52         except:
  53             ""
  54         self.close_db(db)
  55         self.new_epg_timeline("")
  56         self.new_in_timeline_log()
  57         self.new_in_auto_bayes_key()
  58         self.new_in_auto_jbk_key()
  59         self.new_in_status()
  60         self.new_in_settings()
  61         self.new_auto_timeline_bayes()
  62         self.new_auto_timeline_keyword()
  63     def connect_db(self):
  64         """
  65         dbへの接続
  66         """
  67         con = MySQLdb.connect(db=self.dbname, host=self.dbhost, port=self.dbport, user=self.dbusr, passwd=self.dbpasswd, charset="utf8")
  68         cur = con.cursor()
  69         cur.execute('set names utf8;')
  70         return [con, cur]
  71     def close_db(self, db):
  72         db[1].close()
  73         db[0].close()
  74     def new_epg_ch(self):
  75         db = self.connect_db()
  76         try:
  77             db[1].execute('drop table epg_ch')
  78         except:
  79             ""
  80         try:
  81             db[1].execute('\
  82             CREATE TABLE epg_ch \
  83             (\
  84             bctype VARCHAR(15),\
  85             ontv VARCHAR(30) PRIMARY KEY,\
  86             chtxt VARCHAR(20),\
  87             ch VARCHAR(20),\
  88             csch VARCHAR(20),\
  89             chname VARCHAR(100),\
  90             updatetime DATETIME,\
  91             status TINYINT,\
  92             isshow TINYINT\
  93             )')
  94         except:
  95             ""
  96         self.close_db(db)
  97     def add_epg_ch(self, bctype, ontv, chtxt, ch, csch, updatetime):
  98         db = self.connect_db()
  99         db[1].execute('\
 100         INSERT INTO epg_ch \
 101         VALUES (%s,%s,%s,%s,%s,"",%s,%s,%s)', \
 102                       (bctype, ontv, chtxt, ch, csch, updatetime, "1","1"))
 103         self.close_db(db)
 104     def select_by_ontv_epg_ch(self, ontv):
 105         db = self.connect_db()
 106         dbexe = db[1].execute("\
 107         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 108         FROM epg_ch \
 109         WHERE ontv = %s", \
 110                               (ontv,))
 111         ret = []
 112         dls = []
 113         if dbexe > 0:
 114             dls = db[1].fetchall()
 115         self.close_db(db)
 116         for dl in dls:
 117             r = list(dl)
 118             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 119             ret.append(r)
 120         return ret
 121     def select_by_chtxt_epg_ch(self, chtxt):
 122         db = self.connect_db()
 123         dbexe = db[1].execute("\
 124         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 125         FROM epg_ch \
 126         WHERE chtxt = %s", \
 127                               (chtxt,))
 128         ret = []
 129         dls = []
 130         if dbexe > 0:
 131             dls = db[1].fetchall()
 132         self.close_db(db)
 133         for dl in dls:
 134             r = list(dl)
 135             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 136             ret.append(r)
 137         return ret
 138     def select_by_bctype_epg_ch(self, bctype):
 139         db = self.connect_db()
 140         dbexe = db[1].execute("\
 141         SELECT bctype,ontv,chtxt,ch,csch,updatetime,status \
 142         FROM epg_ch \
 143         WHERE bctype = %s", \
 144                               (bctype,))
 145         ret = []
 146         dls = []
 147         if dbexe > 0:
 148             dls = db[1].fetchall()
 149         self.close_db(db)
 150         for dl in dls:
 151             #recdblist.printutf8(dl)
 152             r = list(dl)
 153             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 154             r[6] = str(r[6])
 155             ret.append(r)
 156         return ret
 157     def select_by_ch_epg_ch(self, ch):
 158         db = self.connect_db()
 159         dbexe = db[1].execute("\
 160         SELECT \
 161         bctype,ontv,chtxt,ch,csch,updatetime \
 162         FROM epg_ch \
 163         WHERE ch = %s", \
 164                               (ch,))
 165         ret = []
 166         dls = []
 167         if dbexe > 0:
 168             dls = db[1].fetchall()
 169         self.close_db(db)
 170         for dl in dls:
 171             r = list(dl)
 172             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 173             ret.append(r)
 174         return ret
 175     def select_all_epg_ch(self):
 176         db = self.connect_db()
 177         dbexe = db[1].execute("\
 178         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 179         FROM epg_ch \
 180         ")
 181         ret = []
 182         dls = []
 183         if dbexe > 0:
 184             dls = db[1].fetchall()
 185         self.close_db(db)
 186         for dl in dls:
 187             r = list(dl)
 188             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 189             ret.append(r)
 190         return ret
 191     def set_new_status(self,dhour):
 192         db = self.connect_db()
 193         dbexe = db[1].execute("UPDATE epg_ch \
 194         SET status = 1 \
 195         WHERE \
 196         ( \
 197         updatetime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR) \
 198         AND \
 199         status = 0 \
 200         )"\
 201         )
 202     def select_get_update_epg_ch(self, dhour):
 203         db = self.connect_db()
 204         dbexe = db[1].execute("SELECT bctype,chtxt,status FROM epg_ch \
 205         WHERE (\
 206         ( \
 207         updatetime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR) \
 208         AND \
 209         status = 1 \
 210         ) \
 211         OR \
 212         status > 1 )\
 213         ORDER BY status DESC")
 214         ret = []
 215         #recdblist.printutf8(dbexe)
 216         if dbexe > 0:
 217             ret = db[1].fetchall()
 218         self.close_db(db)
 219         return ret
 220     def update_by_bctype_epg_ch(self, bctype):
 221         db = self.connect_db()
 222         db[1].execute("\
 223         UPDATE epg_ch \
 224         SET \
 225         updatetime=now() , \
 226         status = 1 \
 227         WHERE bctype = %s", (bctype,))
 228         self.close_db(db)
 229     def update_by_bctype_and_chtxt_epg_ch(self, bctype, chtxt):
 230         db = self.connect_db()
 231         db[1].execute("\
 232         UPDATE epg_ch \
 233         SET \
 234         updatetime=now() , \
 235         status = 1\
 236         WHERE bctype = %s AND chtxt = %s", (bctype, chtxt))
 237         self.close_db(db)
 238     def update_status_by_bctype_epg_ch(self, bctype, status):
 239         db = self.connect_db()
 240         db[1].execute("\
 241         UPDATE epg_ch \
 242         SET \
 243         status=%s , \
 244         updatetime=now() \
 245         WHERE bctype = %s", \
 246                       (status, bctype)\
 247                       )
 248         self.close_db(db)
 249     def update_chname_by_ontv_epg_ch(self,ontv,chname):
 250         db = self.connect_db()
 251         db[1].execute("\
 252         UPDATE epg_ch \
 253         SET \
 254         chname=%s \
 255         WHERE ontv = %s", \
 256                       (chname, ontv)\
 257                       )
 258         self.close_db(db)
 259     def add_auto_proc_tmp(self,type,title,chtxt):
 260         db = self.connect_db()
 261         db[1].execute('\
 262         INSERT IGNORE into auto_proc_tmp \
 263         (type,title,chtxt) \
 264         values (%s,%s,%s)',(type,title,chtxt))
 265         ##db.commit()
 266         self.close_db(db)
 267     def new_auto_proc_tmp(self):
 268         db = self.connect_db()
 269         try:
 270             db[1].execute('drop table auto_proc_tmp')
 271         except:
 272             ""
 273         try:
 274             db[1].execute('\
 275             CREATE TABLE auto_proc_tmp \
 276             (\
 277             type VARCHAR(20),\
 278             title VARCHAR(100) PRIMARY KEY,\
 279             chtxt VARCHAR(30),\
 280             UNIQUE unibayeskey(title)\
 281             )')
 282         except:
 283             ""
 284         self.close_db(db)
 285     def update_auto_proc(self):
 286         db = self.connect_db()
 287         try:
 288             db[1].execute('INSERT INTO auto_proc SELECT * FROM auto_proc_tmp')
 289         except:
 290             ""
 291         self.close_db(db)
 292     def new_auto_proc(self):
 293         db = self.connect_db()
 294         try:
 295             db[1].execute('drop table auto_proc')
 296         except:
 297             ""
 298         try:
 299             db[1].execute('\
 300             CREATE TABLE auto_proc \
 301             (\
 302             type VARCHAR(20),\
 303             title VARCHAR(100) PRIMARY KEY,\
 304             chtxt VARCHAR(30),\
 305             UNIQUE unibayeskey(title)\
 306             )')
 307         except:
 308             ""
 309         self.close_db(db)
 310     def add_auto_proc(self,type,title,chtxt):
 311         db = self.connect_db()
 312         db[1].execute('\
 313         INSERT IGNORE into auto_proc \
 314         (type,title,chtxt) \
 315         values (%s,%s,%s)',(type,title,chtxt))
 316         ##db.commit()
 317         self.close_db(db)
 318     def drop_in_settings(self):
 319         db = self.connect_db()
 320         try:
 321             db[1].execute('drop table in_settings')
 322         except:
 323             ""
 324         self.close_db(db)
 325     def new_in_settings(self):
 326         db = self.connect_db()
 327         try:
 328             db[1].execute('\
 329             CREATE TABLE in_settings \
 330             (\
 331             auto_jbk TINYINT,\
 332             auto_bayes TINYINT,\
 333             auto_opt VARCHAR(20),\
 334             auto_del_tmp TINYINT\
 335             )')
 336             db[1].execute("INSERT IGNORE into in_settings VALUE (0,0,\"G\",1)")
 337         except:
 338             ""
 339         self.close_db(db)
 340     def select_all_in_settings(self):
 341         db = self.connect_db()
 342         dbexe = db[1].execute("\
 343         SELECT auto_jbk,auto_bayes,auto_del_tmp,auto_opt \
 344         FROM in_settings \
 345         ")
 346         ret = []
 347         dls = []
 348         if dbexe > 0:
 349             dls = db[1].fetchall()
 350         self.close_db(db)
 351         for dl in dls:
 352             r = list(dl)
 353             r[0]=str(r[0])
 354             r[1]=str(r[1])
 355             r[2]=str(r[2])
 356             r[3]=r[3]
 357             ret.append(r)
 358         return ret
 359     def add_in_timeline_log(self , chtxt="", title="", btime="", etime="", opt="", exp="", longexp="", category=""):
 360         db = self.connect_db()
 361         db[1].execute('\
 362         INSERT IGNORE into in_timeline_log \
 363         (chtxt,title,btime,etime,opt,exp,longexp,category) \
 364         values (%s,%s,%s,%s,%s,%s,%s,%s)', \
 365                       ( chtxt, title, btime, etime, opt,exp,longexp,category))
 366         ##db.commit()
 367         self.close_db(db)
 368     def del_in_timeline_log(self, title="", chtxt="", btime=""):
 369         """
 370
 371         """
 372         db = self.connect_db()
 373         db[1].execute("\
 374         DELETE FROM in_timeline_log \
 375         WHERE title = %s AND chtxt = %s AND btime = %s", \
 376                       (title, chtxt, btime))
 377         #db.commit()
 378         self.close_db(db)
 379     def new_in_timeline_log(self):
 380         db = self.connect_db()
 381         try:
 382             db[1].execute('\
 383             CREATE TABLE in_timeline_log \
 384             (\
 385             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 386             chtxt VARCHAR(20),\
 387             title VARCHAR(100),\
 388             btime DATETIME,\
 389             etime DATETIME,\
 390             opt VARCHAR(20),\
 391             exp VARCHAR(200),\
 392             longexp TEXT,\
 393             category VARCHAR(100),\
 394             UNIQUE uni (chtxt,title,btime,category)\
 395             )')
 396         except:
 397             ""
 398         self.close_db(db)
 399     def select_chtxt_by_title_timeline_log(self,title):
 400         db = self.connect_db()
 401         dbexe = db[1].execute("\
 402         SELECT chtxt \
 403         FROM in_timeline_log \
 404         WHERE title LIKE \"%"+title+"%\"\
 405         GROUP by chtxt\
 406         ORDER by sum(1) DESC limit 1")
 407         retdb=db[1].fetchall()
 408         ret=""
 409         if ret!=None:
 410             if len(retdb)>0:
 411                 ret=retdb[0][0]
 412         self.close_db(db)
 413         return ret
 414     def add_timeline(self, type="", chtxt="", title="", btime="", etime="", deltatime="", deltaday="", opt=""):
 415         db = self.connect_db()
 416         db[1].execute('\
 417         INSERT IGNORE into timeline \
 418         (type,chtxt,title,btime,etime,deltatime,deltaday,opt) \
 419         values (%s,%s,%s,%s,%s,%s,%s,%s)', \
 420                       (type, chtxt, title, btime, etime, deltatime, deltaday, opt))
 421         ##db.commit()
 422         self.close_db(db)
 423     def update_epg_timeline(self,type,chtxt,title,btime,epgbtime,epgetime,epgtitle):
 424         db = self.connect_db()
 425         db[1].execute('\
 426         UPDATE timeline \
 427         SET epgbtime=%s,epgetime=%s,epgtitle=%s \
 428         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 429                       (epgbtime,epgetime,epgtitle,type, chtxt, title, btime))
 430         ##db.commit()
 431         self.close_db(db)
 432     def update_status_change_timeline(self,type,chtxt,title,btime,epgchange):
 433         db = self.connect_db()
 434         db[1].execute('\
 435         UPDATE timeline \
 436         SET epgchange =%s \
 437         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 438                       (epgchange , type, chtxt, title, btime))
 439         ##db.commit()
 440         self.close_db(db)
 441     def update_status_dup_timeline(self,type,chtxt,title,btime,epgduplicate):
 442         db = self.connect_db()
 443         db[1].execute('\
 444         UPDATE timeline \
 445         SET epgduplicate =%s \
 446         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 447                       (epgduplicate , type, chtxt, title, btime))
 448         ##db.commit()
 449         self.close_db(db)
 450     def del_timeline(self, type="", title="", chtxt="", btime=""):
 451         """
 452
 453         """
 454         db = self.connect_db()
 455         db[1].execute("\
 456         DELETE FROM timeline \
 457         WHERE type = %s AND title = %s AND chtxt = %s AND btime = %s", \
 458                       (type, title, chtxt, btime))
 459         #db.commit()
 460         self.close_db(db)
 461     def select_all_timeline(self):
 462         db = self.connect_db()
 463         recdata = []
 464         dbr = db[1].execute("\
 465         SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 466         FROM timeline")
 467         dbl = db[1].fetchall()
 468         self.close_db(db)
 469         if dbr > 0:
 470             recdata = self.getdic_timeline(dbl)
 471         return recdata
 472     def select_bytime_timeline(self, dminutes):
 473         db = self.connect_db()
 474         recdatum = []
 475         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 476         dbr = db[1].execute("SELECT \
 477         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 478         FROM timeline \
 479         WHERE btime BETWEEN DATE_SUB(now(),INTERVAL " + dminutes + " MINUTE ) AND \
 480         DATE_ADD(now(),INTERVAL " + dminutes + " MINUTE )")
 481         dbl = db[1].fetchall()
 482         self.close_db(db)
 483         #recdblist.printutf8(dbl)
 484         if dbr > 0:
 485             recdatum = self.getdic_timeline(dbl)
 486         return recdatum
 487     def select_by_name_time_timeline(self,title,btime,btime2):
 488         db = self.connect_db()
 489         recdatum = []
 490         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 491         dbr = db[1].execute("SELECT \
 492         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 493         FROM timeline \
 494         WHERE btime > %s AND \
 495         btime < %s AND title = %s",(btime,btime2,title))
 496         dbl = db[1].fetchall()
 497         self.close_db(db)
 498         #recdblist.printutf8(dbl)
 499         if dbr > 0:
 500             recdatum = self.getdic_timeline(dbl)
 501         return recdatum
 502     def select_bytime_all_timeline(self,btime,etime):
 503         db = self.connect_db()
 504         recdatum = []
 505         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 506         dbr = db[1].execute("SELECT \
 507         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 508         FROM timeline \
 509         WHERE btime > %s AND \
 510         etime < %s",(btime,etime))
 511         dbl = db[1].fetchall()
 512         self.close_db(db)
 513         #recdblist.printutf8(dbl)
 514         if dbr > 0:
 515             recdatum = self.getdic_timeline(dbl)
 516         return recdatum
 517     def select_byepgtime_all_timeline(self,epgbtime,epgetime):
 518         db = self.connect_db()
 519         recdatum = []
 520         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 521         dbr = db[1].execute("SELECT \
 522         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 523         FROM timeline \
 524         WHERE epgbtime >= %s AND \
 525         epgetime <= %s",(epgbtime,epgetime))
 526         dbl = db[1].fetchall()
 527         self.close_db(db)
 528         #recdblist.printutf8(dbl)
 529         if dbr > 0:
 530             recdatum=self.getdic_timeline(dbl)
 531         return recdatum
 532     def select_byepgtime_over_timeline(self,epgbtime,epgetime):
 533         db = self.connect_db()
 534         recdatum = []
 535         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 536         dbr = db[1].execute("SELECT \
 537         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 538         FROM timeline \
 539         WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"\
 540         ,(epgbtime,epgetime))
 541         dbl = db[1].fetchall()
 542         self.close_db(db)
 543         #recdblist.printutf8(dbl)
 544         if dbr > 0:
 545             recdatum=self.getdic_timeline(dbl)
 546         return recdatum
 547     def count_schedule_timeline(self, btime, etime):
 548         """
 549         count rectasknum
 550         return [te num,bs/cs num]
 551         """
 552         db = self.connect_db()
 553         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 554         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 555         Srec = 0
 556         Trec = 0
 557         db[1].execute(dbexe, (btime, etime,btime,etime))
 558         dbl=db[1].fetchall()
 559         for typet, bctypet, chtxtt, titlet in dbl:
 560             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 561                 if bctypet.find("cs") > -1:
 562                     Srec = Srec + 1
 563                 elif bctypet.find("bs") > -1:
 564                     Srec = Srec + 1
 565                 elif bctypet.find("te") > -1:
 566                     Trec = Trec + 1
 567         self.close_db(db)
 568         return [Trec, Srec]
 569     def search_schedule_timeline(self,btime,etime):
 570         """
 571         count rectasknum
 572         return [(type,bctype,chtxt,title,btime,etime)]
 573         """
 574         db = self.connect_db()
 575         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title,timeline.btime,timeline.etime FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 576         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 577         ret=[]
 578         db[1].execute(dbexe, (btime, etime,btime,etime))
 579         dbl=db[1].fetchall()
 580         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 581             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 582                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 583         self.close_db(db)
 584         return ret
 585     def count_epgschedule_timeline(self, epgbtime, epgetime):
 586         """
 587         count rectasknum
 588         return [te num,bs/cs num]
 589         """
 590         db = self.connect_db()
 591         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 592         dbexe = dbexe + " WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"
 593         Srec = 0
 594         Trec = 0
 595         db[1].execute(dbexe, (epgbtime, epgetime))
 596         dbl=db[1].fetchall()
 597         for typet, bctypet, chtxtt, titlet in dbl:
 598             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 599                 if bctypet.find("cs") > -1:
 600                     Srec = Srec + 1
 601                 elif bctypet.find("bs") > -1:
 602                     Srec = Srec + 1
 603                 elif bctypet.find("te") > -1:
 604                     Trec = Trec + 1
 605         self.close_db(db)
 606         return [Trec, Srec]
 607     def search_epgschedule_timeline(self,epgbtime,epgetime):
 608         """
 609         count rectasknum
 610         return [(type,bctype,chtxt,title,btime,etime)]
 611         """
 612         db = self.connect_db()
 613         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title,timeline.btime,timeline.etime FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 614         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 615         ret=[]
 616         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 617         dbl=db[1].fetchall()
 618         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 619             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 620                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 621         self.close_db(db)
 622         return ret
 623     def select_bytime_bychtxt_all_timeline(self,btime,etime,chtxt):
 624         db = self.connect_db()
 625         recdatum = []
 626         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 627         dbr = db[1].execute("SELECT \
 628         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 629         FROM timeline \
 630         WHERE btime > %s AND \
 631         etime < %s\
 632         AND chtxt=%s ",(btime,etime,chtxt))
 633         dbl = db[1].fetchall()
 634         self.close_db(db)
 635         #recdblist.printutf8(dbl)
 636         if dbr > 0:
 637             recdatum = self.getdic_timeline(dbl)
 638         return recdatum
 639     def getdic_timeline(self,timelinelists):
 640         recdatum=[]
 641         for typet, chtxt, title, btime, etime, deltatime, deltaday, opt ,epgbtimet , epgetimet ,epgtitlet ,epgduplicatet ,epgchanget  in timelinelists:
 642             ret = {}
 643             ret['type'] = typet
 644             ret['chtxt'] = chtxt
 645             ret['title'] = title
 646             btime = btime.strftime("%Y-%m-%d %H:%M:%S")
 647             etime = etime.strftime("%Y-%m-%d %H:%M:%S")
 648             ret['btime'] = btime
 649             ret['etime'] = etime
 650             ret['opt'] = opt
 651             try:
 652                 ret['epgbtime'] = epgbtimet.strftime("%Y-%m-%d %H:%M:%S")
 653                 ret['epgetime'] = epgetimet.strftime("%Y-%m-%d %H:%M:%S")
 654             except:
 655                 ret['epgbtime'] = "2010-01-01 00:00:00"
 656                 ret['epgetime'] = "2010-01-01 00:00:00"
 657             ret['epgtitle'] = epgtitlet
 658             ret['epgduplicate'] = epgduplicatet
 659             ret['epgchange'] = epgchanget
 660             if deltatime == None or deltatime == "":
 661                 deltatime = "3"
 662             if deltaday == None or deltaday == "":
 663                 deltaday = "7"
 664             if typet == recdblist.REC_KEYWORD:
 665                 ret['deltatime'] = deltatime
 666             elif typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS:
 667                 ret['deltatime'] = deltatime
 668                 ret['deltaday'] = deltaday
 669             recdatum.append(ret)
 670         return recdatum
 671     def delete_old_timeline(self, dhour):
 672         db = self.connect_db()
 673         db[1].execute("\
 674         DELETE FROM timeline \
 675         WHERE \
 676         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 677         #db.commit()
 678         self.close_db(db)
 679     def new_in_auto_jbk_key(self):
 680         db = self.connect_db()
 681         try:
 682             db[1].execute("\
 683             CREATE TABLE in_auto_jbk_key \
 684             (\
 685             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 686             keyword VARCHAR(200),\
 687             UNIQUE unijbk (keyword)\
 688             )")
 689         except:
 690             ""
 691         self.close_db(db)
 692     def add_in_auto_jbk_key(self,key):
 693         db = self.connect_db()
 694         db[1].execute('\
 695         INSERT IGNORE into in_auto_jbk_key \
 696         (keyword) \
 697         values (%s)', \
 698                       (key,))
 699         ##db.commit()
 700         self.close_db(db)
 701     def select_all_in_auto_jbk_key(self):
 702         db = self.connect_db()
 703         dbexe = db[1].execute("\
 704         SELECT keyword \
 705         FROM in_auto_jbk_key \
 706         ")
 707         ret = []
 708         if dbexe > 0:
 709             ret = db[1].fetchall()
 710         self.close_db(db)
 711         return ret
 712     def drop_in_status(self):
 713         db = self.connect_db()
 714         try:
 715             db[1].execute('drop table in_status')
 716         except:
 717             ""
 718         self.close_db(db)
 719     def new_in_status(self):
 720         db = self.connect_db()
 721         try:
 722             db[1].execute("\
 723             CREATE TABLE in_status \
 724             (\
 725             ts2avi TINYINT DEFAULT 0,\
 726             terec TINYINT DEFAULT 0,\
 727             bscsrec TINYINT DEFAULT 0,\
 728             b252ts TINYINT DEFAULT 0,\
 729             installed TINYINT DEFAULT 0\
 730             )")
 731             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 732         except:
 733             ""
 734         self.close_db(db)
 735     def select_all_in_status(self):
 736         db = self.connect_db()
 737         dbexe = db[1].execute("\
 738         SELECT ts2avi,terec,bscsrec,b252ts \
 739         FROM in_status \
 740         ")
 741         ret = []
 742         dls = []
 743         if dbexe > 0:
 744             dls = db[1].fetchall()
 745         self.close_db(db)
 746         for dl in dls:
 747             r = list(dl)
 748             r[0]=str(r[0])
 749             r[1]=str(r[1])
 750             r[2]=str(r[2])
 751             r[3]=str(r[3])
 752             ret.append(r)
 753         return ret
 754
 755     def change_ts2avi_in_status(self,i):
 756         """
 757         statuをiだけ増減する
 758         iはint
 759         """
 760         db = self.connect_db()
 761         db[1].execute("\
 762         UPDATE in_status SET ts2avi=ts2avi+%s",i)
 763         self.close_db(db)
 764     def change_terec_in_status(self,i):
 765         """
 766         statuをiだけ増減する
 767         iはint
 768         """
 769         db = self.connect_db()
 770         db[1].execute("\
 771         UPDATE in_status SET terec=terec+%s",i)
 772         self.close_db(db)
 773     def change_bscsrec_in_status(self,i):
 774         """
 775         statuをiだけ増減する
 776         iはint
 777         """
 778         db = self.connect_db()
 779         db[1].execute("\
 780         UPDATE in_status SET bscsrec=bscsrec+%s",i)
 781         self.close_db(db)
 782     def change_b252ts_in_status(self,i):
 783         """
 784         statuをiだけ増減する
 785         iはint
 786         """
 787         db = self.connect_db()
 788         db[1].execute("\
 789         UPDATE in_status SET b252ts=b252ts+%s",i)
 790         self.close_db(db)
 791     def select_installed_in_status(self):
 792         db = self.connect_db()
 793         dbexe = db[1].execute("\
 794         SELECT ts2avi,terec,bscsrec,b252ts,installed \
 795         FROM in_status \
 796         ")
 797         ret = 0
 798         dls = []
 799         if dbexe > 0:
 800             dls = db[1].fetchall()
 801         self.close_db(db)
 802         for dl in dls:
 803             r = list(dl)
 804             ret=r[4]
 805         return ret
 806     def change_installed_in_status(self):
 807         """
 808         installedを設定する
 809         """
 810         db = self.connect_db()
 811         db[1].execute("\
 812         UPDATE in_status SET installed=1")
 813         self.close_db(db)
 814     def new_epg_timeline(self, bctype):
 815         db = self.connect_db()
 816         try:
 817             db[1].execute("\
 818             DELETE FROM epg_timeline \
 819             WHERE bctype = %s", \
 820                           (bctype,))
 821         except:
 822             ""
 823         try:
 824             db[1].execute("\
 825             CREATE TABLE epg_timeline \
 826             (\
 827             bctype VARCHAR(20),\
 828             channel VARCHAR(100) NOT NULL,\
 829             start VARCHAR(30),\
 830             stop  VARCHAR(30),\
 831             title VARCHAR(100),\
 832             exp VARCHAR(200),\
 833             longexp TEXT,\
 834             category VARCHAR(100),\
 835             UNIQUE unitv(bctype,channel,start,stop,title)\
 836             )")
 837         except:
 838             ""
 839         #db.commit()
 840         self.close_db(db)
 841     def add_epg_timeline(self, bctype, channel, start, stop, title, desc,longdesc, category):
 842         db = self.connect_db()
 843         db[1].execute('\
 844         INSERT IGNORE INTO epg_timeline \
 845         VALUES (%s,%s,%s,%s,%s,%s,%s,%s)', \
 846                       (bctype, channel, start, stop, title, desc,longdesc,category))
 847         #db.commit()
 848         self.close_db(db)
 849     def add_multi_epg_timeline(self, tvlists):
 850         """
 851         tvlists is (bctype,channel,start,stop,title,desc,longdesc,category) lists.
 852         """
 853         db = self.connect_db()
 854         db[1].executemany('\
 855         INSERT IGNORE INTO epg_timeline \
 856         (bctype,channel,start,stop,title,exp,longexp,category) \
 857         values(%s,%s,%s,%s,%s,%s,%s,%s)', \
 858                           tvlists)
 859         self.close_db(db)
 860     def select_by_time_ngram_epg_timeline(self, btime, etime, chtxt):
 861         db = self.connect_db()
 862         dbexe = "\
 863         SELECT \
 864         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 865         FROM epg_timeline \
 866         INNER JOIN epg_ch \
 867         WHERE epg_ch.ontv=epg_timeline.channel \
 868         AND \
 869         start >= %s \
 870         AND \
 871         start <= %s \
 872         AND \
 873         epg_ch.chtxt=%s"
 874         dbcmd = db[1].execute(dbexe, (btime, etime, chtxt))
 875         retall = []
 876         if dbcmd > 0:
 877             retall = db[1].fetchall()
 878         self.close_db(db)
 879         return retall
 880     def select_by_time_keyword_auto_suggest_epg_timeline(self,keyword,btime,etime):
 881         db = self.connect_db()
 882         dbexe = "\
 883         SELECT \
 884         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 885         FROM epg_timeline \
 886         INNER JOIN epg_ch \
 887         WHERE epg_ch.ontv=epg_timeline.channel \
 888         AND \
 889         start >= %s \
 890         AND \
 891         stop <= %s \
 892         AND \
 893         ( \
 894         ( title LIKE \'%%"+keyword+"%%\' ) \
 895         OR \
 896         ( exp LIKE \'%%"+keyword+"%%\' ) \
 897         OR \
 898         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 899         )"
 900         dbcmd = db[1].execute(dbexe,(btime, etime))
 901         retall = []
 902         if dbcmd > 0:
 903             retall = db[1].fetchall()
 904         self.close_db(db)
 905         return retall
 906     def new_in_auto_bayes_key(self):
 907         db = self.connect_db()
 908         try:
 909             db[1].execute('CREATE TABLE in_auto_bayes_key \
 910             (\
 911             keychar VARCHAR(10),\
 912             chtxt VARCHAR(20),\
 913             ratio_rec DECIMAL(32,14),\
 914             ratio_all DECIMAL(32,14),\
 915             UNIQUE unibayeskey(keychar,chtxt)\
 916             )')
 917             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 918         except:
 919             ""
 920         self.close_db(db)
 921
 922     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 923         db = self.connect_db()
 924         ratio_rec=str(ratio_rec)
 925         ratio_all=str(ratio_all)
 926         db[1].execute('\
 927         INSERT IGNORE INTO in_auto_bayes_key \
 928         (keychar,chtxt,ratio_rec,ratio_all) \
 929         values (%s,%s,%s,%s)',\
 930         (key,chtxt,ratio_rec,ratio_all))
 931         self.close_db(db)
 932     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 933         db = self.connect_db()
 934         add_rec_num=str(add_rec_num)
 935         add_all_num=str(add_all_num)
 936         db[1].execute("\
 937         UPDATE in_auto_bayes_key SET ratio_rec=CONVERT(ratio_rec+%s,DECIMAL(32,14)),ratio_all=CONVERT(ratio_all+%s,DECIMAL(32,14)) WHERE keychar=\"NUM\" AND chtxt=%s",\
 938         (add_rec_num,add_all_num,chtxt))
 939         self.close_db(db)
 940     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 941         """
 942         """
 943         db = self.connect_db()
 944         db[1].execute("\
 945         UPDATE in_auto_bayes_key SET ratio_rec=%s,ratio_all=%s WHERE keychar=%s AND chtxt=%s",(str(new_ratio_rec),str(new_ratio_all),key,chtxt)\
 946         )
 947         self.close_db(db)
 948     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 949         beforenum=str(beforenum)
 950         newnum=str(newnum)
 951         db = self.connect_db()
 952         db[1].execute("\
 953         UPDATE in_auto_bayes_key SET ratio_all=CONVERT(ratio_all*%s/(%s+%s),DECIMAL(32,14)) WHERE chtxt=%s AND NOT (keychar=\"NUM\")",(beforenum,newnum,beforenum,chtxt)\
 954         )
 955         self.close_db(db)
 956     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 957         db = self.connect_db()
 958         beforenumf=beforenum
 959         beforenum=str(beforenum)
 960         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 961         VALUES (%s,%s,%s,%s)\
 962         ON DUPLICATE KEY UPDATE \
 963         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
 964         self.close_db(db)
 965     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
 966         """
 967         list={key:addnum}のリスト
 968         """
 969         beforenumf=beforenum
 970         beforenum=str(beforenum)
 971         db = self.connect_db()
 972         for i,j in list.items():
 973             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
 974             try:
 975                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 976                 VALUES (%s,%s,%s,%s)\
 977                 ON DUPLICATE KEY UPDATE \
 978                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
 979             except:
 980                 ""
 981         self.close_db(db)
 982     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 983         beforenum=str(beforenum)
 984         newnum=str(newnum)
 985         db = self.connect_db()
 986         db[1].execute("\
 987         UPDATE in_auto_bayes_key SET ratio_rec=CONVERT(ratio_rec*%s/(%s+%s),DECIMAL(32,14)) WHERE chtxt=%s AND NOT (keychar=\"NUM\")",(beforenum,newnum,beforenum,chtxt)\
 988         )
 989         self.close_db(db)
 990     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 991         db = self.connect_db()
 992         beforenumf=beforenum
 993         beforenum=str(beforenum)
 994         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 995         VALUES (%s,%s,%s,%s)\
 996         ON DUPLICATE KEY UPDATE \
 997         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
 998         self.close_db(db)
 999     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
1000         beforenumf=beforenum
1001         beforenum=str(beforenum)
1002         db = self.connect_db()
1003         for i,j in list.items():
1004             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
1005             try:
1006                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1007                 VALUES (%s,%s,%s,%s)\
1008                 ON DUPLICATE KEY UPDATE \
1009                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
1010             except:
1011                 ""
1012         self.close_db(db)
1013     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1014         db = self.connect_db()
1015         dbexe = db[1].execute("\
1016         SELECT keychar,chtxt,ratio_rec,ratio_all \
1017         FROM in_auto_bayes_key \
1018         WHERE keychar = %s AND chtxt = %s", \
1019                               (key,chtxt))
1020         dls = []
1021         if dbexe > 0:
1022             dls = db[1].fetchall()
1023         self.close_db(db)
1024         if len(dls)>0:
1025             return dls[0]
1026         else:
1027             return dls
1028
1029     def new_auto_timeline_keyword(self):
1030         db = self.connect_db()
1031         try:
1032             db[1].execute('\
1033             CREATE TABLE auto_timeline_keyword \
1034             (\
1035             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1036             chtxt VARCHAR(40),\
1037             title VARCHAR(100),\
1038             btime DATETIME,\
1039             etime DATETIME,\
1040             UNIQUE uni (chtxt,title,btime,etime)\
1041             )')
1042         except:
1043             ""
1044     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1045         db = self.connect_db()
1046         db[1].execute('\
1047         INSERT IGNORE into auto_timeline_keyword \
1048         (chtxt,title,btime,etime) \
1049         values (%s,%s,%s,%s)', \
1050                        (chtxt, title, btime, etime))
1051         ##db.commit()
1052         self.close_db(db)
1053     def delete_old_auto_timeline_keyword(self, dhour):
1054         db = self.connect_db()
1055         db[1].execute("\
1056         DELETE FROM auto_timeline_keyword \
1057         WHERE \
1058         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1059         self.close_db(db)
1060     def new_auto_timeline_bayes(self):
1061         db = self.connect_db()
1062         try:
1063             db[1].execute('\
1064             CREATE TABLE auto_timeline_bayes \
1065             (\
1066             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1067             chtxt VARCHAR(40),\
1068             title VARCHAR(100),\
1069             btime DATETIME,\
1070             etime DATETIME,\
1071             point INT,\
1072             UNIQUE uni (chtxt,title,btime,etime)\
1073             )')
1074         except:
1075             ""
1076     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1077         db = self.connect_db()
1078         db[1].execute('\
1079         INSERT IGNORE into auto_timeline_bayes \
1080         (chtxt,title,btime,etime,point) \
1081         values (%s,%s,%s,%s,%s)', \
1082                       (chtxt, title, btime, etime,point))
1083         self.close_db(db)
1084     def delete_old_auto_timeline_bayes(self, dhour):
1085         db = self.connect_db()
1086         db[1].execute("\
1087         DELETE FROM auto_timeline_bayes \
1088         WHERE \
1089         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1090         self.close_db(db)