cbgetter.py

   1 # -*- coding: utf-8 -*-
   2 """Get data from database and publish them."""
   3 from json import dumps
   4 from random import randint
   5 from requests import post
   6 from cbconf import Conf
   7 from cbdb import Db
   8
   9 class CoffeebotGetter:
  10     """This class connects configuration, database access and publishing."""
  11     def __init__(self):
  12         self.cfg = Conf()
  13         self.db = Db(self.cfg.getCoffeeDbPath())
  14         self.msg = ""
  15         self.top = []
  16         self.topeq = []
  17         self.isuff = {1: "st", 2: "nd", 3: "rd", 4: "th", 5: "th"}
  18         return None
  19
  20     def getMsg(self):
  21         """Return message."""
  22         return self.msg
  23
  24     def sendMsgToSlack(self):
  25         """Send message to Slack Bot."""
  26         return post(self.cfg.getCoffeebotURL(), dumps({"text": self.msg}))
  27
  28     def get_drink_smile(self, drink):
  29         """Return Slack smile for ``drink``.
  30
  31         Keyword arguments:
  32         drink -- Drink of smile.
  33         """
  34         smiles = {
  35             "tea": ":tea:",
  36             "espresso": ":coffee:",
  37             "espresso lungo": ":coffin:",
  38             "cappuccino": ":flara:",
  39             "latte macchiato": ":baby_bottle:",
  40             "Club-Mate 0,5 l": ":club-mate:",
  41             "Club-Mate 0,33 l": ":club-mate_cola:",
  42         }
  43         return smiles[drink]
  44
  45     def getHeroComment(self):
  46         """Return comment for hero."""
  47         hsuff = [
  48             ", oops",
  49             " - real hero",
  50             " because couldn't resist",
  51             " - drunken master",
  52             ", woohoo",
  53             " - unbeatable",
  54             " - superultramaxidrinker",
  55             " and didn't sleep last week",
  56             " in last 604800 seconds",
  57             ", no idea how",
  58             " and still drinking",
  59         ]
  60         ri = randint(0, len(hsuff) - 1)
  61         return hsuff[ri]
  62
  63     def getSomeSmile(self):
  64         """Return some Slack smile."""
  65         smiles = [
  66             ":party_parrot:",
  67             ":cat2:",
  68             ":heavy_check_mark:",
  69             ":baby_bottle:",
  70             ":+1:",
  71             ":aaw_yeah:",
  72             ":better:",
  73         ]
  74         ri = randint(0, len(smiles) - 1)
  75         return smiles[ri]
  76
  77     def computeEqualDrinkers(self):
  78         """Compute equally drunken drinkers."""
  79         if len(self.top) <= 0:
  80             return
  81         lc = self.top[0][1] + 1
  82         for (un, c) in self.top:
  83             if c < lc:
  84                 self.topeq.append([])
  85                 lc = c
  86             self.topeq[-1].append((un, c))
  87         return
  88
  89     def load_top_drinks(self):
  90         """Get list of top drinks, update message."""
  91         self.msg = "*Top drinks*\n"
  92         self.top = self.db.get_top_drinks()
  93         self.computeEqualDrinkers()
  94         i = 1
  95         for drinks in self.topeq[:3]:
  96             c = drinks[0][1]
  97             d = [un for (un, c) in drinks]
  98             self.msg += "{}{}".format(i, self.isuff[i])
  99             if len(d) > 1:
 100                 self.msg += " are "
 101             else:
 102                 self.msg += " is "
 103             for un in d:
 104                 if un is d[0]:
 105                     self.msg += "{}".format(self.get_drink_smile(un))
 106                 elif un is d[-1]:
 107                     self.msg += "" if len(d) == 2 else ","
 108                     self.msg += " and {}".format(self.get_drink_smile(un))
 109                 else:
 110                     self.msg += ", *{}*".format(self.get_drink_smile(un))
 111             if len(d) > 1:
 112                 self.msg += " with each of "
 113             else:
 114                 self.msg += " with "
 115             self.msg += "`{}` drunk".format(c)
 116             self.msg += "\n"
 117             i += 1
 118
 119     def loadTopMateDrinkers(self):
 120         """Get list of top Mate drinkers, update message."""
 121         self.msg = "*Top 5 Club-Mate drinkers*\n"
 122         self.top = self.db.getTopMateDrinkers()
 123         self.computeEqualDrinkers()
 124         totl = [c for (un, c) in self.top]
 125         tot = sum(totl)
 126         i = 1
 127         for drinkers in self.topeq[:5]:
 128             c = drinkers[0][1]
 129             d = [un for (un, c) in drinkers]
 130             self.msg += "{}{}".format(i, self.isuff[i])
 131             if len(d) > 1:
 132                 self.msg += " are "
 133             else:
 134                 self.msg += " is "
 135             for un in d:
 136                 if un is d[0]:
 137                     self.msg += "*{}*".format(un)
 138                 elif un is d[-1]:
 139                     self.msg += "" if len(d) == 2 else ","
 140                     self.msg += " and *{}*".format(un)
 141                 else:
 142                     self.msg += ", *{}*".format(un)
 143             if len(d) > 1:
 144                 self.msg += " of whom each drank "
 145             else:
 146                 self.msg += " who drank "
 147             self.msg += "`{:.2f}` liters".format(c)
 148             if i == 1:
 149                 self.msg += self.getHeroComment()
 150             self.msg += "\n"
 151             i += 1
 152         self.msg += "\n"
 153         self.msg += "Oh, and together we drank *{:.2f}* liters {}".format(
 154             tot,
 155             self.getSomeSmile()
 156         )
 157         return
 158
 159     def load_top_tea_drinkers(self):
 160         """Get list of top tea drinkers, update message."""
 161         self.msg = "*Top 5 tea drinkers*\n"
 162         self.top = self.db.get_top_tea_drinkers()
 163         self.computeEqualDrinkers()
 164         tot = sum([c for (un, c) in self.top])
 165         i = 1
 166         for drinkers in self.topeq[:5]:
 167             c = drinkers[0][1]
 168             d = [un for (un, c) in drinkers]
 169             self.msg += "{}{}".format(i, self.isuff[i])
 170             if len(d) > 1:
 171                 self.msg += " are "
 172             else:
 173                 self.msg += " is "
 174             for un in d:
 175                 if un is d[0]:
 176                     self.msg += "*{}*".format(un)
 177                 elif un is d[-1]:
 178                     self.msg += "" if len(d) == 2 else ","
 179                     self.msg += " and *{}*".format(un)
 180                 else:
 181                     self.msg += ", *{}*".format(un)
 182             if len(d) > 1:
 183                 self.msg += " of whom each drank "
 184             else:
 185                 self.msg += " who drank "
 186             if c > 1:
 187                 self.msg += "`{}` teas".format(c)
 188             else:
 189                 self.msg += "`{}` tea".format(c)
 190             self.msg += "\n"
 191             i += 1
 192         self.msg += "\n"
 193         self.msg += "Oh, and together we drank *{}* teas {}".format(
 194             tot,
 195             self.getSomeSmile()
 196         )
 197
 198     def loadDrunkSum(self, *args, **kwargs):
 199         """Get list of drunken ``flavor`` from ``dtf`` to ``dtt``, update msg.
 200
 201         Keyword arguments:
 202         flavor -- The flavor of beverage.
 203         dtf -- Date and time *from*.
 204         dtt -- Date and time *to*.
 205         """
 206         self.top = self.db.getDrunkSum(*args, **kwargs)
 207         if args:
 208             flavor = args[0]
 209             dtf = args[1]
 210             dtt = args[2]
 211         elif kwargs:
 212             flavor = kwargs["flavor"]
 213             dtf = kwargs["dtf"]
 214             dtt = kwargs["dtt"]
 215         self.msg = "{} drunk from {} to {}:\n".format(flavor, dtf, dtt)
 216         for (un, cnt) in self.top:
 217             self.msg += "{}: {}\n".format(un, cnt)
 218         self.msg += "---"
 219         return
 220
 221     def loadDrunkList(self, *args, **kwargs):
 222         """Get list of drunken ``flavor`` from ``dtf`` to ``dtt``, update msg.
 223
 224         Keyword arguments:
 225         flavor -- The flavor of beverage.
 226         dtf -- Date and time *from*.
 227         dtt -- Date and time *to*.
 228         """
 229         self.top = self.db.getDrunkSum(*args, **kwargs)
 230         d = self.db.getDrunkList(*args, **kwargs)
 231         if args:
 232             flavor = args[0]
 233             dtf = args[1]
 234             dtt = args[2]
 235         elif kwargs:
 236             flavor = kwargs["flavor"]
 237             dtf = kwargs["dtf"]
 238             dtt = kwargs["dtt"]
 239         self.msg = "{} drunk from {} to {}:\n".format(flavor, dtf, dtt)
 240         for (un, l) in d.items():
 241             self.msg += "{}: ".format(un)
 242             for cnt in l[:-1]:
 243                 self.msg += "{}, ".format(cnt)
 244             self.msg += "{}\n".format(l[-1])
 245         self.msg += "---"
 246         return