vcs.maemo.org Git - multilist/blob - src/libspeichern.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 """
   5 This file is part of Multilist.
   6
   7 Multilist is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 Multilist is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Multilist.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 Copyright (C) 2008 Christoph Würstle
  21 """
  22
  23 import time
  24 import sqlite3
  25 import shelve
  26 import sys
  27 import string
  28 import shutil
  29 import os
  30 import logging
  31
  32 try:
  33         _
  34 except NameError:
  35         _ = lambda x: x
  36
  37
  38 _moduleLogger = logging.getLogger(__name__)
  39
  40
  41 class Speichern(object):
  42
  43         def __init__(self):
  44                 home_dir = os.path.expanduser('~')
  45                 filename = os.path.join(home_dir, ".multilist.dat")
  46                 self.d = shelve.open(filename)
  47                 self.openDB()
  48
  49         def openDB(self):
  50                 try:
  51                         self.cur.close()
  52                 except:
  53                         pass
  54                 try:
  55                         self.conn.close()
  56                 except:
  57                         pass
  58
  59                 db = self.ladeDirekt("datenbank")
  60                 if db == "":
  61                         home_dir = os.path.expanduser('~')
  62                         db = os.path.join(home_dir, "multilist.s3db")
  63
  64                 datum = time.strftime("%Y-%m-%d--", (time.localtime(time.time())))+str(int(time.time()))+"--"
  65                 if (os.path.exists(db))and(os.path.exists(os.path.dirname(db)+os.sep+"backup/")):
  66                         try:
  67                                 shutil.copyfile(db, str(os.path.dirname(db))+os.sep+"backup"+os.sep+datum+os.path.basename(db))
  68                                 #_moduleLogger.debug(str(os.path.dirname(db))+os.sep+"backup"+os.sep+datum+os.path.basename(db))
  69                         except:
  70                                 _moduleLogger.info("Achtung Backup-Datei NICHT (!!!) angelegt!")
  71                                 #print db, str(os.path.dirname(db))+os.sep+"backup"+os.sep+datum+os.path.basename(db)
  72
  73                 self.conn = sqlite3.connect(db)
  74                 self.cur = self.conn.cursor()
  75                 try:
  76                         sql = "CREATE TABLE logtable (id INTEGER PRIMARY KEY AUTOINCREMENT, pcdatum INTEGER , sql TEXT, param TEXT, host TEXT, rowid TEXT)"
  77                         self.cur.execute(sql)
  78                         self.conn.commit()
  79                 except:
  80                         pass
  81
  82                 #Add rowid line (not in old versions included)
  83                 try:
  84                         sql = "ALTER TABLE logtable ADD rowid TEXT"
  85                         self.cur.execute(sql)
  86                         self.conn.commit()
  87                 except:
  88                         pass
  89
  90         def close(self):
  91                 try:
  92                         self.d.close()
  93                 except:
  94                         pass
  95                 try:
  96                         self.cur.close()
  97                 except:
  98                         pass
  99                 try:
 100                         self.conn.close()
 101                 except:
 102                         pass
 103                 _moduleLogger.info("Alle Daten gespeichert")
 104
 105         def __del__(self):
 106                 self.close()
 107
 108         def speichereDirekt(self, schluessel, daten):
 109                 self.d[schluessel] = daten
 110                 _moduleLogger.info("speichereDirekt "+str(schluessel)+" "+str(daten)+" lesen: "+str(self.d[schluessel]))
 111
 112         def ladeDirekt(self, schluessel, default = ""):
 113                 if self.d.has_key(schluessel):
 114                         data = self.d[schluessel]
 115                         return data
 116                 else:
 117                         return default
 118
 119         def speichereSQL(self, sql, tupel = None, commit = True, host = "self", log = True, pcdatum = None, rowid = ""):
 120                 #print "speichereSQL:", sql, tupel
 121                 try:
 122                         programSQLError = True
 123                         if (tupel == None):
 124                                 self.cur.execute(sql)
 125                         else:
 126                                 self.cur.execute(sql, tupel)
 127                         programSQLError = False
 128
 129                         #print int(time.time()), sql, pickle.dumps(tupel), host
 130                         if (log == True):
 131                                 strtupel = []
 132                                 if (tupel is not None):
 133                                         for t in tupel:
 134                                                 strtupel.append(str(t))
 135
 136                                 if pcdatum == None:
 137                                         pcdatum = int(time.time())
 138                                 self.cur.execute("INSERT INTO logtable ( pcdatum, sql, param, host, rowid ) VALUES (?, ?, ?, ?, ?)", (pcdatum, sql, string.join(strtupel, " <<Tren-ner>> "), host, str(rowid) ))
 139                         if commit:
 140                                 self.conn.commit()
 141                         return True
 142                 except:
 143                         s = str(sys.exc_info())
 144                         if (s.find(" already exists") == -1):
 145                         #if len(s)>0:
 146                                 if (programSQLError == True):
 147                                         _moduleLogger.error("speichereSQL-Exception "+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 148                                 else:
 149                                         _moduleLogger.error("speichereSQL-Exception in Logging!!!! :"+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 150                         return False
 151
 152         def commitSQL(self):
 153                 self.conn.commit()
 154
 155         def ladeSQL(self, sql, tupel = None):
 156                 #print sql, tupel
 157                 try:
 158                         if (tupel == None):
 159                                 self.cur.execute(sql)
 160                         else:
 161                                 self.cur.execute(sql, tupel)
 162                         return self.cur.fetchall()
 163                 except:
 164                         _moduleLogger.error("ladeSQL-Exception "+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 165                         return ()
 166
 167         def ladeHistory(self, sql_condition, param_condition):
 168                 sql = "SELECT * FROM logtable WHERE sql LIKE '%"+str(sql_condition)+"%' AND param LIKE '%"+str(param_condition)+"%'"
 169                 rows = self.ladeSQL(sql)
 170
 171                 erg = []
 172                 for row in rows:
 173                         datum = time.strftime("%d.%m.%y %H:%M:%S", (time.localtime(row[1])))
 174                         erg.append([row[1], datum, row[2], row[3], row[3].split(" <<Tren-ner>> ")])
 175
 176                 return erg
 177
 178         def delHistory(self, sql_condition, param_condition, exceptTheLastXSeconds = 0):
 179                 pcdatum = int(time.time())-exceptTheLastXSeconds
 180                 sql = "DELETE FROM logtable WHERE sql LIKE '%"+str(sql_condition)+"%' AND param LIKE '%"+str(param_condition)+"%' AND pcdatum<?"
 181                 self.speichereSQL(sql, (pcdatum, ))
 182
 183         def delHistoryWithRowID(self, rowid, sql_condition = " ", exceptTheLastXSeconds = 0):
 184                 pcdatum = int(time.time())-exceptTheLastXSeconds
 185                 sql = "DELETE FROM logtable WHERE rowid = ? AND pcdatum<? AND sql LIKE '%"+str(sql_condition)+"%'"
 186                 self.speichereSQL(sql, (rowid, pcdatum, ))