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