def index(request):
context = RequestContext(request)
context['taps'] = models.KegTap.objects.all()
events = models.SystemEvent.objects.all()[:10]
context['initial_events'] = kbjson.dumps(
[protolib.ToDict(e, full=True) for e in events], indent=None)
sessions = models.DrinkingSession.objects.all().order_by('-id')[:10]
context['sessions'] = sessions
context['initial_sessions'] = kbjson.dumps(
[protolib.ToDict(s, full=True) for s in sessions], indent=None)
if sessions:
last_session = sessions[0]
context['last_session'] = last_session
if sessions and last_session.IsActiveNow():
context['current_session'] = last_session
if sessions.count() > 1:
context['last_session'] = sessions[1]
else:
context['last_session'] = None
taps = models.KegTap.objects.filter(current_keg__isnull=False)
context['initial_taps'] = kbjson.dumps(
[protolib.ToDict(t, full=True) for t in taps], indent=None)
context['have_events'] = len(events) > 0
context['have_taps'] = len(taps) > 0
return render_to_response('index.html', context_instance=context)
def index(request):
context = RequestContext(request)
try:
page = kegweb_models.Page.objects.get(name__exact='MainPage',
status__exact='published')
except kegweb_models.Page.DoesNotExist:
page = None
context['page_node'] = page
context['taps'] = request.kbsite.taps.all()
try:
session = request.kbsite.sessions.latest()
if session.IsActiveNow():
context['current_session'] = session
except models.DrinkingSession.DoesNotExist:
pass
recent_images = models.Picture.objects.filter(
site=request.kbsite, drink__isnull=False).order_by('-time')[:9]
context['recent_images'] = recent_images
events = request.kbsite.events.all()[:10]
context['initial_events'] = kbjson.dumps(
[protolib.ToDict(e, full=True) for e in events], indent=None)
sessions = request.kbsite.sessions.all().order_by('-seqn')[:10]
context['initial_sessions'] = kbjson.dumps(
[protolib.ToDict(s, full=True) for s in sessions], indent=None)
return render_to_response('index.html', context)
def webhook_post(url, event):
"""Posts an event to the supplied URL.
The request body is a JSON dictionary of:
* type: webhook message type (currently always 'event')
* data: webhook data (the event payload)
Event payloads are in the same format as the /api/events/ endpoint.
"""
logger.info('Posting webhook: url=%s event=%s' % (url, event))
event_dict = protolib.ToDict(event)
hook_dict = {
'type': 'event',
'data': event_dict,
}
headers = {
'content-type': 'application/json',
'user-agent': 'Kegbot/%s' % get_version(),
}
try:
return requests.post(url,
data=kbjson.dumps(hook_dict),
headers=headers)
except requests.exceptions.RequestException, e:
logger.warning('Error posting hook: %s' % e)
return False
def handle_event(self, event):
self.logger.info("Handling new event: %s" % event.id)
settings = self.get_site_settings()
urls = settings.get("webhook_urls", "").strip().split()
event_dict = protolib.ToDict(event, full=True)
for url in urls:
with SuppressTaskErrors(self.logger):
tasks.webhook_post.delay(url, event_dict)
def RecordDrink(self,
tap_name,
ticks,
volume_ml=None,
username=None,
pour_time=None,
duration=0,
auth_token=None,
spilled=False,
do_postprocess=True):
tap = self._GetTapFromName(tap_name)
if not tap:
raise BackendError, "Tap unknown"
if volume_ml is None:
volume_ml = float(ticks) * tap.ml_per_tick
user = None
if username:
user = self._GetUserObjFromUsername(username)
if not pour_time:
pour_time = datetime.datetime.now()
keg = None
if tap.current_keg and tap.current_keg.status == 'online':
keg = tap.current_keg
if spilled:
if not keg:
self._logger.warning(
'Got spilled pour for tap missing keg; ignoring')
return
keg.spilled_ml += volume_ml
keg.save()
return
d = models.Drink(ticks=ticks,
site=self._site,
keg=keg,
user=user,
volume_ml=volume_ml,
starttime=pour_time,
duration=duration,
auth_token=auth_token)
models.DrinkingSession.AssignSessionForDrink(d)
d.save()
if do_postprocess:
d.PostProcess()
hook_url = self._site.settings.event_web_hook
if hook_url:
events = models.SystemEvent.objects.filter(drink=d)
if events:
event_list = [protolib.ToDict(e) for e in events]
tasks.post_webhook_event.delay(hook_url, event_list)
return protolib.ToProto(d)
def handle_event(self, event):
self.logger.info('Handling new event: %s' % event.id)
settings = self.get_site_settings()
url = self.generate_slack_msg()
event_dict = protolib.ToDict(event, full=True)
msg = self.generate_slack_msg(settings, event_dict)
if 'image' in event_dict:
image_file = self.get_image_file(event_dict['image']['url'])
if post:
with SuppressTaskErrors(self.logger):
tasks.slack_post.delay(url, post)
def post_webhook_event(hook_url, event_list):
post_data = kbjson.dumps(
{'events': [protolib.ToDict(e) for e in event_list]})
post_data = urlencode({'payload': post_data})
opener = urllib2.build_opener()
opener.addheaders = [
('User-agent', 'Kegbot/%s' % util.get_version('kegbot')),
]
try:
opener.open(hook_url, data=post_data, timeout=5)
return True
except urllib2.URLError:
return False
def handle_event(self, event):
self.logger.info('Handling new event: %s' % event.id)
settings = self.get_site_settings()
event_dict = protolib.ToDict(event, full=True)
msg = self.generate_slack_msg(settings, event_dict)
#import ipdb; ipdb.set_trace()
try:
url = event_dict['drink']['images'][0]['original_url']
except:
url = None
if url:
image_file = '/home/federico/kegbot-data/' + url.split('/', 3)[3]
else:
image_file = ''
with SuppressTaskErrors(self.logger):
tasks.slack_post(self.slack_config(), msg, image_file)
def dump(output_fp, kbsite, indent=None, log_cb=_no_log):
"""Produce a dump of this Kegbot system to the given filestream.
In its current format, the dump is plaintext JSON string consisting of all
important data, including tap configuration, drink history, and user account
details.
All "derived" tables are NOT backed up. These are tables with data that can
be regenerated at any time without any loss of history. Specifically:
- session chunks
- user session chunks
- keg session chunks
- keg stats
- user stats
- session stats
- system events
"""
res = {}
items = (
('bdb_brewers', bdb_models.Brewer.objects.all()),
('bdb_styles', bdb_models.BeerStyle.objects.all()),
('bdb_beertypes', bdb_models.BeerType.objects.all()),
('thermosensors', kbsite.thermosensors.all().order_by('id')),
('coinselectors', kbsite.coinselectors.all().order_by('id')),
('kegs', kbsite.kegs.all().order_by('id')),
('taps', kbsite.taps.all().order_by('id')),
('sessions', kbsite.sessions.all().order_by('id')),
('thermologs', kbsite.thermologs.all().order_by('-id')[:60*24]),
('thermosummarylogs', kbsite.thermosummarylogs.all().order_by('id')),
('users', models.User.objects.all().order_by('id')),
('profiles', models.UserProfile.objects.all().order_by('id')),
('drinks', kbsite.drinks.valid().order_by('id')),
('tokens', kbsite.tokens.all().order_by('id')),
)
log_cb('Generating backup data ...')
for name, qs in items:
log_cb(' .. dumping %s' % name)
res[name] = list(protolib.ToDict(qs, full=True))
log_cb('Serializing and writing backup data ...')
output_fp.write(kbjson.dumps(res, indent=indent))
def obj_to_dict(o):
return protolib.ToDict(o)
