git.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 from __future__ import with_statement
  24
  25 import sys
  26 import os
  27 import time
  28 import sqlite3
  29 import shelve
  30 import string
  31 import shutil
  32 import logging
  33
  34 try:
  35         _
  36 except NameError:
  37         _ = lambda x: x
  38
  39
  40 _moduleLogger = logging.getLogger(__name__)
  41
  42
  43 class Speichern(object):
  44
  45         def __init__(self):
  46                 home_dir = os.path.expanduser('~')
  47                 filename = os.path.join(home_dir, ".multilist.dat")
  48                 self.d = shelve.open(filename)
  49                 self.openDB()
  50
  51         def openDB(self):
  52                 try:
  53                         self.cur.close()
  54                 except:
  55                         pass
  56                 try:
  57                         self.conn.close()
  58                 except:
  59                         pass
  60
  61                 db = self.ladeDirekt("datenbank")
  62                 if db == "":
  63                         home_dir = os.path.expanduser('~')
  64                         db = os.path.join(home_dir, "multilist.s3db")
  65
  66                 datum = time.strftime("%Y-%m-%d--", (time.localtime(time.time())))+str(int(time.time()))+"--"
  67                 if os.path.exists(db) and os.path.exists(os.path.dirname(db)+os.sep+"backup"):
  68                         try:
  69                                 shutil.copyfile(db, str(os.path.dirname(db))+os.sep+"backup"+os.sep+datum+os.path.basename(db))
  70                         except:
  71                                 _moduleLogger.info("Achtung Backup-Datei NICHT (!!!) angelegt!")
  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                 try:
 121                         programSQLError = True
 122                         if tupel is None:
 123                                 self.cur.execute(sql)
 124                         else:
 125                                 self.cur.execute(sql, tupel)
 126                         programSQLError = False
 127
 128                         if log:
 129                                 strtupel = []
 130                                 if tupel is not None:
 131                                         for t in tupel:
 132                                                 strtupel.append(str(t))
 133
 134                                 if pcdatum is None:
 135                                         pcdatum = int(time.time())
 136                                 self.cur.execute("INSERT INTO logtable ( pcdatum, sql, param, host, rowid ) VALUES (?, ?, ?, ?, ?)", (pcdatum, sql, string.join(strtupel, " <<Tren-ner>> "), host, str(rowid) ))
 137                         if commit:
 138                                 self.conn.commit()
 139                         return True
 140                 except:
 141                         s = str(sys.exc_info())
 142                         if s.find(" already exists") == -1:
 143                                 if programSQLError:
 144                                         _moduleLogger.error("speichereSQL-Exception "+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 145                                 else:
 146                                         _moduleLogger.error("speichereSQL-Exception in Logging!!!! :"+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 147                         return False
 148
 149         def commitSQL(self):
 150                 self.conn.commit()
 151
 152         def ladeSQL(self, sql, tupel = None):
 153                 try:
 154                         if tupel is None:
 155                                 self.cur.execute(sql)
 156                         else:
 157                                 self.cur.execute(sql, tupel)
 158                         return self.cur.fetchall()
 159                 except:
 160                         _moduleLogger.error("ladeSQL-Exception "+str(sys.exc_info())+" "+str(sql)+" "+str(tupel))
 161                         return ()
 162
 163         def ladeHistory(self, sql_condition, param_condition):
 164                 sql = "SELECT * FROM logtable WHERE sql LIKE '%"+str(sql_condition)+"%' AND param LIKE '%"+str(param_condition)+"%'"
 165                 rows = self.ladeSQL(sql)
 166
 167                 erg = []
 168                 for row in rows:
 169                         datum = time.strftime("%d.%m.%y %H:%M:%S", (time.localtime(row[1])))
 170                         erg.append([row[1], datum, row[2], row[3], row[3].split(" <<Tren-ner>> ")])
 171
 172                 return erg
 173
 174         def delHistory(self, sql_condition, param_condition, exceptTheLastXSeconds = 0):
 175                 pcdatum = int(time.time())-exceptTheLastXSeconds
 176                 sql = "DELETE FROM logtable WHERE sql LIKE '%"+str(sql_condition)+"%' AND param LIKE '%"+str(param_condition)+"%' AND pcdatum<?"
 177                 self.speichereSQL(sql, (pcdatum, ))
 178
 179         def delHistoryWithRowID(self, rowid, sql_condition = " ", exceptTheLastXSeconds = 0):
 180                 pcdatum = int(time.time())-exceptTheLastXSeconds
 181                 sql = "DELETE FROM logtable WHERE rowid = ? AND pcdatum<? AND sql LIKE '%"+str(sql_condition)+"%'"
 182                 self.speichereSQL(sql, (rowid, pcdatum, ))