coffee_getter/db.py

   1 # -*- coding: utf-8 -*-
   2 """Database access."""
   3 from sqlite3 import connect
   4
   5 class FileNotSetError(ValueError):
   6     pass
   7
   8 class ArgCountError(ValueError):
   9     pass
  10
  11 class Db:
  12     def __init__(self, dbpath=False):
  13         if dbpath:
  14             self.con = connect(dbpath)
  15         else:
  16             self.con = None
  17             raise FileNotSetError("Database file must be set")
  18         self.cur = self.con.cursor()
  19         return None
  20
  21     def __del__(self):
  22         if self.con:
  23             self.con.close()
  24
  25     def get_top_drinks(self):
  26         """Return list of pairs of drink name and count."""
  27         q = """
  28
  29         SELECT count(*), flavor
  30         FROM coffees
  31         WHERE time BETWEEN
  32             datetime('now', 'localtime', '-7 days')
  33             AND datetime('now', 'localtime')
  34         GROUP BY flavor
  35
  36         """
  37         top = []
  38         for (cnt, dn) in self.cur.execute(q):
  39             top.append((dn, cnt))
  40         top.sort(key=lambda x: (x[1], x[0]), reverse=True)
  41         return top
  42
  43     def getTopMateDrinkers(self):
  44         """Return list of pairs of name, count for Mate drinkers."""
  45         users = {}
  46         que = """
  47
  48         SELECT count(*), users.name FROM coffees
  49         LEFT JOIN identifiers on coffees.id = identifiers.id
  50         LEFT JOIN users on identifiers.userid = users.id
  51         WHERE flavor = 'Club-Mate 0,5 l'
  52         AND coffees.time BETWEEN
  53             datetime('now', 'localtime', '-7 days') AND
  54             datetime('now', 'localtime')
  55         GROUP BY identifiers.userid
  56
  57         """
  58         for (cnt, un) in self.cur.execute(que):
  59             users[un] = cnt * 0.5
  60         que = """
  61
  62         SELECT count(*), users.name FROM coffees
  63         LEFT JOIN identifiers on coffees.id = identifiers.id
  64         LEFT JOIN users on identifiers.userid = users.id
  65         WHERE flavor = 'Club-Mate 0,33 l'
  66         AND coffees.time BETWEEN
  67             datetime('now', 'localtime', '-7 days') AND
  68             datetime('now', 'localtime')
  69         GROUP BY identifiers.userid
  70
  71         """
  72         for (cnt, un) in self.cur.execute(que):
  73             if un in users:
  74                 users[un] += cnt * 0.33
  75             else:
  76                 users[un] = cnt * 0.33
  77         top = []
  78         for (un, cnt) in users.items():
  79             top.append((un, cnt))
  80         top.sort(key=lambda x: (x[1], x[0]), reverse=True)
  81         return top
  82
  83     def get_top_tea_drinkers(self):
  84         """Return list of pairs of name, count for tea drinkers."""
  85         q = """
  86
  87         SELECT count(*), users.name FROM coffees
  88         LEFT JOIN identifiers on coffees.id = identifiers.id
  89         LEFT JOIN users on identifiers.userid = users.id
  90         WHERE flavor = 'tea'
  91         AND coffees.time BETWEEN
  92             datetime('now', 'localtime', '-7 days') AND
  93             datetime('now', 'localtime')
  94         GROUP BY identifiers.userid
  95
  96         """
  97         top = []
  98         for (cnt, un) in self.cur.execute(q):
  99             top.append((un, cnt))
 100         top.sort(key=lambda x: (x[1], x[0]), reverse=True)
 101         return top
 102
 103     def getDrunkSum(self, *args, **kwargs):
 104         """Return list of drunken ``flavor`` from ``dtf`` to ``dtt``.
 105
 106         Keyword arguments:
 107         flavor -- The flavor of beverage.
 108         dtf -- Date and time *from*.
 109         dtt -- Date and time *to*.
 110         """
 111         if not ((len(args) == 3 and len(kwargs) == 0) or
 112                 (len(args) == 0 and len(kwargs) == 3)):
 113             raise ArgCountError("3 arguments needed: flavor, from, and to")
 114         if args:
 115             flavor = args[0]
 116             dtf = args[1]
 117             dtt = args[2]
 118         elif kwargs:
 119             flavor = kwargs["flavor"]
 120             dtf = kwargs["dtf"]
 121             dtt = kwargs["dtt"]
 122         flavors = flavor.split(";")
 123         que = """
 124             SELECT count(*), users.name FROM coffees
 125             INNER JOIN users ON coffees.id = users.id
 126         """
 127         for f in flavors:
 128             if f is flavors[0]:
 129                 que += "WHERE flavor = '{}'".format(f)
 130             else:
 131                 que += "OR flavor = '{}'".format(f)
 132         que += """
 133             AND coffees.time BETWEEN
 134                 datetime('{}', 'localtime') AND
 135                 datetime('{}', 'localtime')
 136             GROUP BY coffees.id
 137         """.format(dtf, dtt)
 138         drunk = []
 139         for (cnt, un) in self.cur.execute(que):
 140             drunk.append((un, cnt))
 141         return drunk
 142
 143     def getDrunkList(self, *args, **kwargs):
 144         """Return dict of lists of drunken ``flavor`` from ``dtf`` to ``dtt``.
 145
 146         Keyword arguments:
 147         flavor -- The flavor of beverage.
 148         dtf -- Date and time *from*.
 149         dtt -- Date and time *to*.
 150         """
 151         if not ((len(args) == 3 and len(kwargs) == 0) or
 152                 (len(args) == 0 and len(kwargs) == 3)):
 153             raise ArgCountError("3 arguments needed: flavor, from, and to")
 154         if args:
 155             flavor = args[0]
 156             dtf = args[1]
 157             dtt = args[2]
 158         elif kwargs:
 159             flavor = kwargs["flavor"]
 160             dtf = kwargs["dtf"]
 161             dtt = kwargs["dtt"]
 162         flavors = flavor.split(";")
 163         drunk = {}
 164         i = 0
 165         for f in flavors:
 166             que = """
 167
 168             SELECT count(*), users.name FROM coffees
 169             LEFT JOIN identifiers on coffees.id = identifiers.id
 170             LEFT JOIN users on identifiers.userid = users.id
 171             WHERE flavor = '{}'
 172             AND coffees.time BETWEEN
 173                 datetime('{}', 'localtime') AND
 174                 datetime('{}', 'localtime')
 175             GROUP BY identifiers.userid
 176
 177             """.format(f, dtf, dtt)
 178             for (cnt, un) in self.cur.execute(que):
 179                 if not un in drunk:
 180                     drunk[un] = [0 for j in range(i)]
 181                 drunk[un].append(cnt)
 182             i += 1
 183         return drunk