coffee_getter/bot.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": ":owl:",
  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         self.topeq = []
  80         if len(self.top) <= 0:
  81             return
  82         lc = self.top[0][1] + 1
  83         for (un, c) in self.top:
  84             if c < lc:
  85                 self.topeq.append([])
  86                 lc = c
  87             self.topeq[-1].append((un, c))
  88         return
  89
  90     def load_top_drinks(self):
  91         """Get list of top drinks, update message."""
  92         self.msg = "*Top drinks*\n"
  93         self.top = self.db.get_top_drinks()
  94         self.computeEqualDrinkers()
  95         i = 1
  96         for drinks in self.topeq[:3]:
  97             c = drinks[0][1]
  98             d = [un for (un, c) in drinks]
  99             self.msg += "{}{}".format(i, self.isuff[i])
 100             if len(d) > 1:
 101                 self.msg += " are "
 102             else:
 103                 self.msg += " is "
 104             for un in d:
 105                 if un is d[0]:
 106                     self.msg += "{}".format(self.get_drink_smile(un))
 107                 elif un is d[-1]:
 108                     self.msg += "" if len(d) == 2 else ","
 109                     self.msg += " and {}".format(self.get_drink_smile(un))
 110                 else:
 111                     self.msg += ", *{}*".format(self.get_drink_smile(un))
 112             if len(d) > 1:
 113                 self.msg += " with each of "
 114             else:
 115                 self.msg += " with "
 116             self.msg += "`{}` drunk".format(c)
 117             self.msg += "\n"
 118             i += 1
 119
 120     def loadTopMateDrinkers(self):
 121         """Get list of top Mate drinkers, update message."""
 122         self.msg = "*Top 5 Club-Mate drinkers*\n"
 123         self.top = self.db.getTopMateDrinkers()
 124         self.computeEqualDrinkers()
 125         totl = [c for (un, c) in self.top]
 126         tot = sum(totl)
 127         i = 1
 128         for drinkers in self.topeq[:5]:
 129             c = drinkers[0][1]
 130             d = [un for (un, c) in drinkers]
 131             self.msg += "{}{}".format(i, self.isuff[i])
 132             if len(d) > 1:
 133                 self.msg += " are "
 134             else:
 135                 self.msg += " is "
 136             for un in d:
 137                 if un is d[0]:
 138                     self.msg += "*{}*".format(un)
 139                 elif un is d[-1]:
 140                     self.msg += "" if len(d) == 2 else ","
 141                     self.msg += " and *{}*".format(un)
 142                 else:
 143                     self.msg += ", *{}*".format(un)
 144             if len(d) > 1:
 145                 self.msg += " of whom each drank "
 146             else:
 147                 self.msg += " who drank "
 148             self.msg += "`{:.2f}` liters".format(c)
 149             if i == 1:
 150                 self.msg += self.getHeroComment()
 151             self.msg += "\n"
 152             i += 1
 153         self.msg += "\n"
 154         self.msg += "Oh, and together we drank *{:.2f}* liters {}".format(
 155             tot,
 156             self.getSomeSmile()
 157         )
 158         return
 159
 160     def load_top_tea_drinkers(self):
 161         """Get list of top tea drinkers, update message."""
 162         self.msg = "*Top 5 tea drinkers*\n"
 163         self.top = self.db.get_top_tea_drinkers()
 164         self.computeEqualDrinkers()
 165         tot = sum([c for (un, c) in self.top])
 166         i = 1
 167         for drinkers in self.topeq[:5]:
 168             c = drinkers[0][1]
 169             d = [un for (un, c) in drinkers]
 170             self.msg += "{}{}".format(i, self.isuff[i])
 171             if len(d) > 1:
 172                 self.msg += " are "
 173             else:
 174                 self.msg += " is "
 175             for un in d:
 176                 if un is d[0]:
 177                     self.msg += "*{}*".format(un)
 178                 elif un is d[-1]:
 179                     self.msg += "" if len(d) == 2 else ","
 180                     self.msg += " and *{}*".format(un)
 181                 else:
 182                     self.msg += ", *{}*".format(un)
 183             if len(d) > 1:
 184                 self.msg += " of whom each drank "
 185             else:
 186                 self.msg += " who drank "
 187             if c > 1:
 188                 self.msg += "`{}` teas".format(c)
 189             else:
 190                 self.msg += "`{}` tea".format(c)
 191             self.msg += "\n"
 192             i += 1
 193         self.msg += "\n"
 194         self.msg += "Oh, and together we drank *{}* teas {}".format(
 195             tot,
 196             self.getSomeSmile()
 197         )
 198
 199     def loadDrunkSum(self, *args, **kwargs):
 200         """Get list of drunken ``flavor`` from ``dtf`` to ``dtt``, update msg.
 201
 202         Keyword arguments:
 203         flavor -- The flavor of beverage.
 204         dtf -- Date and time *from*.
 205         dtt -- Date and time *to*.
 206         """
 207         self.top = self.db.getDrunkSum(*args, **kwargs)
 208         if args:
 209             flavor = args[0]
 210             dtf = args[1]
 211             dtt = args[2]
 212         elif kwargs:
 213             flavor = kwargs["flavor"]
 214             dtf = kwargs["dtf"]
 215             dtt = kwargs["dtt"]
 216         self.msg = "{} drunk from {} to {}:\n".format(flavor, dtf, dtt)
 217         for (un, cnt) in self.top:
 218             self.msg += "{}: {}\n".format(un, cnt)
 219         self.msg += "---"
 220         return
 221
 222     def loadDrunkList(self, *args, **kwargs):
 223         """Get list of drunken ``flavor`` from ``dtf`` to ``dtt``, update msg.
 224
 225         Keyword arguments:
 226         flavor -- The flavor of beverage.
 227         dtf -- Date and time *from*.
 228         dtt -- Date and time *to*.
 229         """
 230         self.top = self.db.getDrunkSum(*args, **kwargs)
 231         d = self.db.getDrunkList(*args, **kwargs)
 232         if args:
 233             flavor = args[0]
 234             dtf = args[1]
 235             dtt = args[2]
 236         elif kwargs:
 237             flavor = kwargs["flavor"]
 238             dtf = kwargs["dtf"]
 239             dtt = kwargs["dtt"]
 240         self.msg = "{} drunk from {} to {}:\n".format(flavor, dtf, dtt)
 241         for (un, l) in d.items():
 242             self.msg += "{}: ".format(un)
 243             for cnt in l[:-1]:
 244                 self.msg += "{}, ".format(cnt)
 245             self.msg += "{}\n".format(l[-1])
 246         self.msg += "---"
 247         return