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 = getdic_timeline(dbl)
 471         self.close_db(db)
 472         return recdata
 473     def select_bytime_timeline(self, dminutes):
 474         db = self.connect_db()
 475         recdatum = []
 476         #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 )")
 477         dbr = db[1].execute("SELECT \
 478         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 479         FROM timeline \
 480         WHERE btime BETWEEN DATE_SUB(now(),INTERVAL " + dminutes + " MINUTE ) AND \
 481         DATE_ADD(now(),INTERVAL " + dminutes + " MINUTE )")
 482         dbl = db[1].fetchall()
 483         self.close_db(db)
 484         #recdblist.printutf8(dbl)
 485         if dbr > 0:
 486             recdatum = getdic_timeline(dbl)
 487         self.close_db(db)
 488         return recdatum
 489     def select_by_name_time_timeline(self,title,btime,btime2):
 490         db = self.connect_db()
 491         recdatum = []
 492         #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 )")
 493         dbr = db[1].execute("SELECT \
 494         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 495         FROM timeline \
 496         WHERE btime > %s AND \
 497         btime < %s AND title = %s",(btime,btime2,title))
 498         dbl = db[1].fetchall()
 499         self.close_db(db)
 500         #recdblist.printutf8(dbl)
 501         if dbr > 0:
 502             recdatum = getdic_timeline(dbl)
 503         self.close_db(db)
 504         return recdatum
 505     def select_bytime_all_timeline(self,btime,etime):
 506         db = self.connect_db()
 507         recdatum = []
 508         #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 )")
 509         dbr = db[1].execute("SELECT \
 510         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 511         FROM timeline \
 512         WHERE btime > %s AND \
 513         etime < %s",(btime,etime))
 514         dbl = db[1].fetchall()
 515         self.close_db(db)
 516         #recdblist.printutf8(dbl)
 517         if dbr > 0:
 518             recdatum = getdic_timeline(dbl)
 519         self.close_db(db)
 520         return recdatum
 521     def select_byepgtime_all_timeline(self,epgbtime,epgetime):
 522         db = self.connect_db()
 523         recdatum = []
 524         #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 )")
 525         dbr = db[1].execute("SELECT \
 526         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 527         FROM timeline \
 528         WHERE epgbtime > %s AND \
 529         epgetime < %s",(epgbtime,epgetime))
 530         dbl = db[1].fetchall()
 531         self.close_db(db)
 532         #recdblist.printutf8(dbl)
 533         if dbr > 0:
 534             recdatum=getdic_timeline(dbl)
 535         self.close_db(db)
 536         return recdatum
 537     def count_schedule_timeline(self, btime, etime):
 538         """
 539         count rectasknum
 540         return [te num,bs/cs num]
 541         """
 542         db = self.connect_db()
 543         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 544         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 545         Srec = 0
 546         Trec = 0
 547         db[1].execute(dbexe, (btime, etime,btime,etime))
 548         dbl=db[1].fetchall()
 549         for typet, bctypet, chtxtt, titlet in dbl:
 550             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 551                 if bctypet.find("cs") > -1:
 552                     Srec = Srec + 1
 553                 elif bctypet.find("bs") > -1:
 554                     Srec = Srec + 1
 555                 elif bctypet.find("te") > -1:
 556                     Trec = Trec + 1
 557         self.close_db(db)
 558         return [Trec, Srec]
 559     def search_schedule_timeline(self,btime,etime):
 560         """
 561         count rectasknum
 562         return [(type,bctype,chtxt,title,btime,etime)]
 563         """
 564         db = self.connect_db()
 565         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"
 566         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 567         ret=[]
 568         db[1].execute(dbexe, (btime, etime,btime,etime))
 569         dbl=db[1].fetchall()
 570         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 571             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 572                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 573         self.close_db(db)
 574         return ret
 575     def count_epgschedule_timeline(self, epgbtime, epgetime):
 576         """
 577         count rectasknum
 578         return [te num,bs/cs num]
 579         """
 580         db = self.connect_db()
 581         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 582         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 583         Srec = 0
 584         Trec = 0
 585         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 586         dbl=db[1].fetchall()
 587         for typet, bctypet, chtxtt, titlet in dbl:
 588             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 589                 if bctypet.find("cs") > -1:
 590                     Srec = Srec + 1
 591                 elif bctypet.find("bs") > -1:
 592                     Srec = Srec + 1
 593                 elif bctypet.find("te") > -1:
 594                     Trec = Trec + 1
 595         self.close_db(db)
 596         return [Trec, Srec]
 597     def search_epgschedule_timeline(self,epgbtime,epgetime):
 598         """
 599         count rectasknum
 600         return [(type,bctype,chtxt,title,btime,etime)]
 601         """
 602         db = self.connect_db()
 603         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"
 604         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 605         ret=[]
 606         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 607         dbl=db[1].fetchall()
 608         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 609             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 610                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 611         self.close_db(db)
 612         return ret
 613     def select_bytime_bychtxt_all_timeline(self,btime,etime,chtxt):
 614         db = self.connect_db()
 615         recdatum = []
 616         #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 )")
 617         dbr = db[1].execute("SELECT \
 618         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 619         FROM timeline \
 620         WHERE btime > %s AND \
 621         etime < %s\
 622         AND chtxt=%s ",(btime,etime,chtxt))
 623         dbl = db[1].fetchall()
 624         self.close_db(db)
 625         #recdblist.printutf8(dbl)
 626         if dbr > 0:
 627             recdatum = getdic_timeline(dbl)
 628         self.close_db(db)
 629         return recdatum
 630     def getdic_timeline(self,timelinelists):
 631         recdatum=[]
 632         for typet, chtxt, title, btime, etime, deltatime, deltaday, opt ,epgbtimet , epgetimet ,epgtitlet ,epgduplicatet ,epgchanget  in timelinelists:
 633             ret = {}
 634             ret['type'] = typet
 635             ret['chtxt'] = chtxt
 636             ret['title'] = title
 637             btime = btime.strftime("%Y-%m-%d %H:%M:%S")
 638             etime = etime.strftime("%Y-%m-%d %H:%M:%S")
 639             ret['btime'] = btime
 640             ret['etime'] = etime
 641             ret['opt'] = opt
 642             ret['epgbtime'] = epgbtimet
 643             ret['epgetime'] = epgetimet
 644             ret['epgtitle'] = epgtitlet
 645             ret['epgduplicate'] = epgduplicatet
 646             ret['epgchange'] = epgchanget
 647             if deltatime == None or deltatime == "":
 648                 deltatime = "3"
 649             if deltaday == None or deltaday == "":
 650                 deltaday = "7"
 651             if typet == recdblist.REC_KEYWORD:
 652                 ret['deltatime'] = deltatime
 653             elif typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS:
 654                 ret['deltatime'] = deltatime
 655                 ret['deltaday'] = deltaday
 656             recdatum.append(ret)
 657         return recdatum
 658     def delete_old_timeline(self, dhour):
 659         db = self.connect_db()
 660         db[1].execute("\
 661         DELETE FROM timeline \
 662         WHERE \
 663         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 664         #db.commit()
 665         self.close_db(db)
 666     def new_in_auto_jbk_key(self):
 667         db = self.connect_db()
 668         try:
 669             db[1].execute("\
 670             CREATE TABLE in_auto_jbk_key \
 671             (\
 672             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 673             keyword VARCHAR(200),\
 674             UNIQUE unijbk (keyword)\
 675             )")
 676         except:
 677             ""
 678         self.close_db(db)
 679     def add_in_auto_jbk_key(self,key):
 680         db = self.connect_db()
 681         db[1].execute('\
 682         INSERT IGNORE into in_auto_jbk_key \
 683         (keyword) \
 684         values (%s)', \
 685                       (key,))
 686         ##db.commit()
 687         self.close_db(db)
 688     def select_all_in_auto_jbk_key(self):
 689         db = self.connect_db()
 690         dbexe = db[1].execute("\
 691         SELECT keyword \
 692         FROM in_auto_jbk_key \
 693         ")
 694         ret = []
 695         if dbexe > 0:
 696             ret = db[1].fetchall()
 697         self.close_db(db)
 698         return ret
 699     def drop_in_status(self):
 700         db = self.connect_db()
 701         try:
 702             db[1].execute('drop table in_status')
 703         except:
 704             ""
 705         self.close_db(db)
 706     def new_in_status(self):
 707         db = self.connect_db()
 708         try:
 709             db[1].execute("\
 710             CREATE TABLE in_status \
 711             (\
 712             ts2avi TINYINT DEFAULT 0,\
 713             terec TINYINT DEFAULT 0,\
 714             bscsrec TINYINT DEFAULT 0,\
 715             b252ts TINYINT DEFAULT 0,\
 716             installed TINYINT DEFAULT 0\
 717             )")
 718             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 719         except:
 720             ""
 721         self.close_db(db)
 722     def select_all_in_status(self):
 723         db = self.connect_db()
 724         dbexe = db[1].execute("\
 725         SELECT ts2avi,terec,bscsrec,b252ts \
 726         FROM in_status \
 727         ")
 728         ret = []
 729         dls = []
 730         if dbexe > 0:
 731             dls = db[1].fetchall()
 732         self.close_db(db)
 733         for dl in dls:
 734             r = list(dl)
 735             r[0]=str(r[0])
 736             r[1]=str(r[1])
 737             r[2]=str(r[2])
 738             r[3]=str(r[3])
 739             ret.append(r)
 740         return ret
 741
 742     def change_ts2avi_in_status(self,i):
 743         """
 744         statuをiだけ増減する
 745         iはint
 746         """
 747         db = self.connect_db()
 748         db[1].execute("\
 749         UPDATE in_status SET ts2avi=ts2avi+%s",i)
 750         self.close_db(db)
 751     def change_terec_in_status(self,i):
 752         """
 753         statuをiだけ増減する
 754         iはint
 755         """
 756         db = self.connect_db()
 757         db[1].execute("\
 758         UPDATE in_status SET terec=terec+%s",i)
 759         self.close_db(db)
 760     def change_bscsrec_in_status(self,i):
 761         """
 762         statuをiだけ増減する
 763         iはint
 764         """
 765         db = self.connect_db()
 766         db[1].execute("\
 767         UPDATE in_status SET bscsrec=bscsrec+%s",i)
 768         self.close_db(db)
 769     def change_b252ts_in_status(self,i):
 770         """
 771         statuをiだけ増減する
 772         iはint
 773         """
 774         db = self.connect_db()
 775         db[1].execute("\
 776         UPDATE in_status SET b252ts=b252ts+%s",i)
 777         self.close_db(db)
 778     def select_installed_in_status(self):
 779         db = self.connect_db()
 780         dbexe = db[1].execute("\
 781         SELECT ts2avi,terec,bscsrec,b252ts,installed \
 782         FROM in_status \
 783         ")
 784         ret = 0
 785         dls = []
 786         if dbexe > 0:
 787             dls = db[1].fetchall()
 788         self.close_db(db)
 789         for dl in dls:
 790             r = list(dl)
 791             ret=r[4]
 792         return ret
 793     def change_installed_in_status(self):
 794         """
 795         installedを設定する
 796         """
 797         db = self.connect_db()
 798         db[1].execute("\
 799         UPDATE in_status SET installed=1")
 800         self.close_db(db)
 801     def new_epg_timeline(self, bctype):
 802         db = self.connect_db()
 803         try:
 804             db[1].execute("\
 805             DELETE FROM epg_timeline \
 806             WHERE bctype = %s", \
 807                           (bctype,))
 808         except:
 809             ""
 810         try:
 811             db[1].execute("\
 812             CREATE TABLE epg_timeline \
 813             (\
 814             bctype VARCHAR(20),\
 815             channel VARCHAR(100) NOT NULL,\
 816             start VARCHAR(30),\
 817             stop  VARCHAR(30),\
 818             title VARCHAR(100),\
 819             exp VARCHAR(200),\
 820             longexp TEXT,\
 821             category VARCHAR(100),\
 822             UNIQUE unitv(bctype,channel,start,stop,title)\
 823             )")
 824         except:
 825             ""
 826         #db.commit()
 827         self.close_db(db)
 828     def add_epg_timeline(self, bctype, channel, start, stop, title, desc,longdesc, category):
 829         db = self.connect_db()
 830         db[1].execute('\
 831         INSERT IGNORE INTO epg_timeline \
 832         VALUES (%s,%s,%s,%s,%s,%s,%s,%s)', \
 833                       (bctype, channel, start, stop, title, desc,longdesc,category))
 834         #db.commit()
 835         self.close_db(db)
 836     def add_multi_epg_timeline(self, tvlists):
 837         """
 838         tvlists is (bctype,channel,start,stop,title,desc,longdesc,category) lists.
 839         """
 840         db = self.connect_db()
 841         db[1].executemany('\
 842         INSERT IGNORE INTO epg_timeline \
 843         (bctype,channel,start,stop,title,exp,longexp,category) \
 844         values(%s,%s,%s,%s,%s,%s,%s,%s)', \
 845                           tvlists)
 846         self.close_db(db)
 847     def select_by_time_ngram_epg_timeline(self, btime, etime, chtxt):
 848         db = self.connect_db()
 849         dbexe = "\
 850         SELECT \
 851         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 852         FROM epg_timeline \
 853         INNER JOIN epg_ch \
 854         WHERE epg_ch.ontv=epg_timeline.channel \
 855         AND \
 856         start >= %s \
 857         AND \
 858         start <= %s \
 859         AND \
 860         epg_ch.chtxt=%s"
 861         dbcmd = db[1].execute(dbexe, (btime, etime, chtxt))
 862         retall = []
 863         if dbcmd > 0:
 864             retall = db[1].fetchall()
 865         self.close_db(db)
 866         return retall
 867     def select_by_time_keyword_auto_suggest_epg_timeline(self,keyword,btime,etime):
 868         db = self.connect_db()
 869         dbexe = "\
 870         SELECT \
 871         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 872         FROM epg_timeline \
 873         INNER JOIN epg_ch \
 874         WHERE epg_ch.ontv=epg_timeline.channel \
 875         AND \
 876         start >= %s \
 877         AND \
 878         stop <= %s \
 879         AND \
 880         ( \
 881         ( title LIKE \'%%"+keyword+"%%\' ) \
 882         OR \
 883         ( exp LIKE \'%%"+keyword+"%%\' ) \
 884         OR \
 885         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 886         )"
 887         dbcmd = db[1].execute(dbexe,(btime, etime))
 888         retall = []
 889         if dbcmd > 0:
 890             retall = db[1].fetchall()
 891         self.close_db(db)
 892         return retall
 893     def new_in_auto_bayes_key(self):
 894         db = self.connect_db()
 895         try:
 896             db[1].execute('CREATE TABLE in_auto_bayes_key \
 897             (\
 898             keychar VARCHAR(10),\
 899             chtxt VARCHAR(20),\
 900             ratio_rec DECIMAL(32,14),\
 901             ratio_all DECIMAL(32,14),\
 902             UNIQUE unibayeskey(keychar,chtxt)\
 903             )')
 904             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 905         except:
 906             ""
 907         self.close_db(db)
 908
 909     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 910         db = self.connect_db()
 911         ratio_rec=str(ratio_rec)
 912         ratio_all=str(ratio_all)
 913         db[1].execute('\
 914         INSERT IGNORE INTO in_auto_bayes_key \
 915         (keychar,chtxt,ratio_rec,ratio_all) \
 916         values (%s,%s,%s,%s)',\
 917         (key,chtxt,ratio_rec,ratio_all))
 918         self.close_db(db)
 919     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 920         db = self.connect_db()
 921         add_rec_num=str(add_rec_num)
 922         add_all_num=str(add_all_num)
 923         db[1].execute("\
 924         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",\
 925         (add_rec_num,add_all_num,chtxt))
 926         self.close_db(db)
 927     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 928         """
 929         """
 930         db = self.connect_db()
 931         db[1].execute("\
 932         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)\
 933         )
 934         self.close_db(db)
 935     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 936         beforenum=str(beforenum)
 937         newnum=str(newnum)
 938         db = self.connect_db()
 939         db[1].execute("\
 940         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)\
 941         )
 942         self.close_db(db)
 943     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 944         db = self.connect_db()
 945         beforenumf=beforenum
 946         beforenum=str(beforenum)
 947         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 948         VALUES (%s,%s,%s,%s)\
 949         ON DUPLICATE KEY UPDATE \
 950         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
 951         self.close_db(db)
 952     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
 953         """
 954         list={key:addnum}のリスト
 955         """
 956         beforenumf=beforenum
 957         beforenum=str(beforenum)
 958         db = self.connect_db()
 959         for i,j in list.items():
 960             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
 961             try:
 962                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 963                 VALUES (%s,%s,%s,%s)\
 964                 ON DUPLICATE KEY UPDATE \
 965                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
 966             except:
 967                 ""
 968         self.close_db(db)
 969     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 970         beforenum=str(beforenum)
 971         newnum=str(newnum)
 972         db = self.connect_db()
 973         db[1].execute("\
 974         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)\
 975         )
 976         self.close_db(db)
 977     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 978         db = self.connect_db()
 979         beforenumf=beforenum
 980         beforenum=str(beforenum)
 981         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 982         VALUES (%s,%s,%s,%s)\
 983         ON DUPLICATE KEY UPDATE \
 984         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
 985         self.close_db(db)
 986     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
 987         beforenumf=beforenum
 988         beforenum=str(beforenum)
 989         db = self.connect_db()
 990         for i,j in list.items():
 991             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
 992             try:
 993                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 994                 VALUES (%s,%s,%s,%s)\
 995                 ON DUPLICATE KEY UPDATE \
 996                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
 997             except:
 998                 ""
 999         self.close_db(db)
1000     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1001         db = self.connect_db()
1002         dbexe = db[1].execute("\
1003         SELECT keychar,chtxt,ratio_rec,ratio_all \
1004         FROM in_auto_bayes_key \
1005         WHERE keychar = %s AND chtxt = %s", \
1006                               (key,chtxt))
1007         dls = []
1008         if dbexe > 0:
1009             dls = db[1].fetchall()
1010         self.close_db(db)
1011         if len(dls)>0:
1012             return dls[0]
1013         else:
1014             return dls
1015
1016     def new_auto_timeline_keyword(self):
1017         db = self.connect_db()
1018         try:
1019             db[1].execute('\
1020             CREATE TABLE auto_timeline_keyword \
1021             (\
1022             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1023             chtxt VARCHAR(40),\
1024             title VARCHAR(100),\
1025             btime DATETIME,\
1026             etime DATETIME,\
1027             UNIQUE uni (chtxt,title,btime,etime)\
1028             )')
1029         except:
1030             ""
1031     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1032         db = self.connect_db()
1033         db[1].execute('\
1034         INSERT IGNORE into auto_timeline_keyword \
1035         (chtxt,title,btime,etime) \
1036         values (%s,%s,%s,%s)', \
1037                        (chtxt, title, btime, etime))
1038         ##db.commit()
1039         self.close_db(db)
1040     def delete_old_auto_timeline_keyword(self, dhour):
1041         db = self.connect_db()
1042         db[1].execute("\
1043         DELETE FROM auto_timeline_keyword \
1044         WHERE \
1045         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1046         self.close_db(db)
1047     def new_auto_timeline_bayes(self):
1048         db = self.connect_db()
1049         try:
1050             db[1].execute('\
1051             CREATE TABLE auto_timeline_bayes \
1052             (\
1053             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1054             chtxt VARCHAR(40),\
1055             title VARCHAR(100),\
1056             btime DATETIME,\
1057             etime DATETIME,\
1058             point INT,\
1059             UNIQUE uni (chtxt,title,btime,etime)\
1060             )')
1061         except:
1062             ""
1063     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1064         db = self.connect_db()
1065         db[1].execute('\
1066         INSERT IGNORE into auto_timeline_bayes \
1067         (chtxt,title,btime,etime,point) \
1068         values (%s,%s,%s,%s,%s)', \
1069                       (chtxt, title, btime, etime,point))
1070         self.close_db(db)
1071     def delete_old_auto_timeline_bayes(self, dhour):
1072         db = self.connect_db()
1073         db[1].execute("\
1074         DELETE FROM auto_timeline_bayes \
1075         WHERE \
1076         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1077         self.close_db(db)