def backwards(self, orm):
for drink in orm.Drink.objects.all():
volume_ml = units.Quantity(drink.volume_ml, units=UNITS.Milliliter)
volume_orig = volume_ml.Amount(in_units=UNITS.KbMeterTick)
drink.volume = volume_orig
drink.save()
for kegsize in orm.KegSize.objects.all():
volume_ml = units.Quantity(kegsize.volume_ml,
units=UNITS.Milliliter)
volume_orig = volume_ml.Amount(in_units=UNITS.KbMeterTick)
kegsize.volume = volume_orig
kegsize.save()
def format_volume(self, volume_ml):
if SiteSettings.get().volume_display_units == 'metric':
if volume_ml < 500:
return '%d mL' % int(volume_ml)
return '%.1f L' % (volume_ml / 1000.0)
else:
return '%1.f oz' % units.Quantity(volume_ml).InOunces()
def clean_volume(self):
volume = self.cleaned_data['volume']
if self.cleaned_data['units'] == 'oz':
self.cleaned_data['volume_ml'] = float(units.Quantity(volume, units.UNITS.Ounce).InMilliliters())
else:
self.cleaned_data['volume_ml'] = volume
return volume
def testKegStuff(self):
"""Test basic keg relations that should always work."""
self.assertEqual(self.keg.full_volume_ml,
units.Quantity(2.0, units.UNITS.Liter).InMilliliters())
self.assertEqual(self.keg.type.producer.name, "Moonshine Beers")
self.assertEqual(0.0, self.keg.served_volume())
self.assertEqual(2000, self.keg.remaining_volume_ml())
def UpdateLastDrink(self, username, volume_ml, date):
vol = units.Quantity(volume_ml, units.UNITS.Milliliter)
size = '%.2f ounces' % vol.InOunces()
when = date.strftime('%b %d %I:%M%p').lower()
f = self._last_drink_frame
f.GetWidget('user').set_contents(username)
f.GetWidget('size').set_contents(size)
f.GetWidget('when').set_contents(when)
def testDrinkAccounting(self):
vol = units.Quantity(1200)
d = self.backend.record_drink(self.tap,
ticks=1200,
username=self.user.username,
)
self.assertEqual(d.keg.served_volume(), d.volume_ml)
def _UpdateFromFlow(self, flow_update):
f = self._pour_frame
user_widget = f.GetWidget('user')
user_widget.set_contents(str(flow_update.username))
amt = units.Quantity(flow_update.volume_ml, units.UNITS.Milliliter)
ounces = amt.InOunces()
ounces_widget = f.GetWidget('ounces')
ounces_widget.set_contents('%.2f' % ounces)
def testDrinkAccounting(self):
vol = units.Quantity(1200)
d = self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=self.user.username,
)
print d
self.assertEqual(self.keg.served_volume(), d.volume_ml)
def set_defaults(force=False, set_is_setup=False):
"""Creates a new site and sets defaults, returning that site."""
if not force and db_is_installed():
raise AlreadyInstalledError("Database is already installed.")
site = models.KegbotSite.get()
if set_is_setup and not site.is_setup:
site.is_setup = True
site.save()
# KegTap defaults
main_tap = models.KegTap(name='Main Tap', meter_name='kegboard.flow0')
main_tap.save()
secondary_tap = models.KegTap(name='Second Tap',
meter_name='kegboard.flow1')
secondary_tap.save()
# brewer defaults
unk_brewer = models.Brewer(name='Unknown Brewer')
unk_brewer.save()
# beerstyle defaults
unk_style = models.BeerStyle(name='Unknown Style')
unk_style.save()
# beertype defaults
unk_type = models.BeerType(name="Unknown Beer",
brewer=unk_brewer,
style=unk_style)
unk_type.save()
# KegSize defaults - from http://en.wikipedia.org/wiki/Keg#Size
default_sizes = (
(DEFAULT_KEG_SIZE_GALLONS, DEFAULT_KEG_SIZE_DESCRIPTION),
(13.2, "Import Keg (European barrel)"),
(7.75, "Pony Keg (quarter barrel)"),
(6.6, "European Half Barrel"),
(5.23, "Sixth Barrel (torpedo keg)"),
(5.0, "Corny Keg"),
(1.0, "Mini Keg"),
)
for gallons, description in default_sizes:
volume = units.Quantity(gallons, units.UNITS.USGallon)
volume_int = volume.Amount(in_units=units.RECORD_UNIT)
ks = models.KegSize(
name=description,
volume_ml=volume_int,
)
ks.save()
return site
def set_defaults(force=False):
""" default values (contents may change with schema) """
if not force and db_is_installed():
raise RuntimeError, "Database is already installed."
site = models.KegbotSite.objects.create(name='default', is_setup=False)
# KegTap defaults
main_tap = models.KegTap(site=site,
name='Main Tap',
meter_name='kegboard.flow0')
main_tap.save()
secondary_tap = models.KegTap(site=site,
name='Second Tap',
meter_name='kegboard.flow1')
secondary_tap.save()
# brewer defaults
unk_brewer = bdb.Brewer(name='Unknown Brewer', id=uuid.uuid4())
unk_brewer.save()
# beerstyle defaults
unk_style = bdb.BeerStyle(name='Unknown Style', id=uuid.uuid4())
unk_style.save()
# beertype defaults
unk_type = bdb.BeerType(name="Unknown Beer",
id=uuid.uuid4(),
brewer=unk_brewer,
style=unk_style)
unk_type.save()
# KegSize defaults - from http://en.wikipedia.org/wiki/Keg#Size
default_sizes = (
(15.5, "Full Keg (half barrel)"),
(13.2, "Import Keg (European barrel)"),
(7.75, "Pony Keg (quarter barrel)"),
(6.6, "European Half Barrel"),
(5.23, "Sixth Barrel (torpedo keg)"),
(5.0, "Corny Keg"),
(1.0, "Mini Keg"),
)
for gallons, description in default_sizes:
volume = units.Quantity(gallons, units.UNITS.USGallon)
volume_int = volume.Amount(in_units=units.RECORD_UNIT)
ks = models.KegSize(
name=description,
volume_ml=volume_int,
)
ks.save()
def setUp(self):
del logging.root.handlers[:]
if not defaults.db_is_installed():
defaults.set_defaults()
models.Drink.objects.all().delete()
self.site, _ = models.KegbotSite.objects.get_or_create(name='default')
self.keg_size = models.KegSize.objects.create(name='10Liter Keg',
volume_ml=units.Quantity(10000))
self.beer_style = bdb_models.BeerStyle.objects.create(name='test style')
self.brewer = bdb_models.Brewer.objects.create(name='test brewer')
self.beer_type = bdb_models.BeerType.objects.create(name='test beer type',
brewer=self.brewer, style=self.beer_style, calories_oz=10.0,
carbs_oz=2.0, abv=5.0)
self.test_keg = models.Keg.objects.create(site=self.site,
type=self.beer_type, size=self.keg_size, status='online',
description='None')
self.test_tap = models.KegTap.objects.create(site=self.site,
name='Test Tap', meter_name='test_meter_name',
ml_per_tick=(1000.0/2200.0), current_keg=self.test_keg)
self.kegbot = kegbot_app.KegbotCoreApp(local_backend=True)
self.env = self.kegbot._env
self.backend = self.env.GetBackend()
self.test_user = self.backend.CreateNewUser('tester')
self.test_token = self.backend.CreateAuthToken('core.onewire',
'0000111122223333', 'tester')
self.test_user_2 = self.backend.CreateNewUser('tester_2')
self.test_token_2 = self.backend.CreateAuthToken('core.onewire',
'baadcafebeeff00d', 'tester_2')
common_defs.AUTH_DEVICE_MAX_IDLE_SECS['core.onewire'] = 2
# Kill the kegbot flow processing thread so we can single step it.
self.service_thread = self.env._service_thread
self.env._threads.remove(self.service_thread)
self.kegbot._Setup()
self.kegbot._StartThreads()
self.client = kegnet.KegnetClient()
while True:
if self.client.Reconnect():
break
def volume(text, fmt='pints'):
try:
vol = units.Quantity(float(text))
except ValueError:
return text
if fmt == 'pints':
res = vol.InPints()
elif fmt == 'liters':
res = vol.InLiters()
elif fmt == 'ounces':
res = vol.InOunces()
elif fmt == 'gallons':
res = vol.InUSGallons()
elif fmt == 'twelveounces':
res = vol.InTwelveOunceBeers()
elif fmt == 'halfbarrels':
res = vol.InHalfBarrelKegs()
else:
raise TemplateSyntaxError, 'Unknown volume format: %s' % fmt
return float(res)
def KegVolumeChart(keg):
if not isinstance(keg, models.Keg):
raise ChartError('Bad value given for keg')
stats = keg.GetStats()
served = units.Quantity(stats.get('total_volume_ml', 0))
served_pints = to_pints(served)
full_pints = to_pints(keg.full_volume())
remain_pints = full_pints - served_pints
res = {
'chart': {
'defaultSeriesType': 'bar',
},
'series': [
{
'data': [served_pints]
},
],
'tooltip': {
'enabled': False,
},
'xAxis': {
'categories': ['Served'],
'labels': {
'enabled': False,
},
'gridLineWidth': 0,
},
'yAxis': {
'endOnTick': False,
'min': 0,
'max': full_pints,
'lineWidth': 0,
'labels': {
'enabled': False,
},
},
}
return res
def format_volume(volume_ml, chart_kwargs):
metric_volumes = chart_kwargs.get('metric_volumes', False)
if metric_volumes:
return volume_ml / 1000.0, 'L'
else:
return units.Quantity(volume_ml).InPints(), 'pints'
def get_default_keg_size():
volume = units.Quantity(DEFAULT_KEG_SIZE_GALLONS, units.UNITS.USGallon)
volume_int = volume.Amount(in_units=units.RECORD_UNIT)
return models.KegSize.objects.get_or_create(
name=DEFAULT_KEG_SIZE_DESCRIPTION, volume_ml=volume_int)[0]
def Volume(self):
return units.Quantity(self.volume_ml)
def __str__(self):
gallons = units.Quantity(self.volume_ml).InUSGallons()
return "%s [%.2f gal]" % (self.name, gallons)
def testDrinkSessions(self):
""" Checks for the DrinkingSession records. """
u1 = self.user
u2 = self.user2
vol = units.Quantity(1200)
drinks = {}
base_time = make_datetime(2009, 1, 1, 1, 0, 0)
ticks = volume = vol.InKbMeterTicks()
td_10m = datetime.timedelta(minutes=10)
td_400m = datetime.timedelta(minutes=400)
td_390m = td_400m - td_10m
self.assertEqual(models.Drink.objects.all().count(), 0)
self.assertEqual(models.DrinkingSession.objects.all().count(), 0)
# u=1 t=0
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u1.username,
pour_time=base_time,
)
# u=2 t=0
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u2.username,
pour_time=base_time,
)
# u=1 t=10
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u1.username,
pour_time=base_time + td_10m,
)
# u=1 t=400
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u1.username,
pour_time=base_time + td_400m,
)
# u=2 t=490
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u2.username,
pour_time=base_time + td_390m,
)
# u=2 t=400
self.backend.RecordDrink(
tap_name=self.tap.meter_name,
ticks=1200,
username=u2.username,
pour_time=base_time + td_400m,
)
drinks_u1 = u1.drinks.all().order_by('time')
drinks_u2 = u2.drinks.all().order_by('time')
u1_chunks = u1.session_chunks.all().order_by('start_time')
self.assertEqual(len(u1_chunks), 2)
u2_chunks = u2.session_chunks.all().order_by('start_time')
self.assertEqual(len(u2_chunks), 2)
s1, s2 = models.DrinkingSession.objects.all().order_by(
'start_time')[:2]
SESSION_DELTA = datetime.timedelta(
minutes=kb_common.DRINK_SESSION_TIME_MINUTES)
# session 1: should be 10 minutes long as created above
self.assertEqual(s1.start_time, drinks_u1[0].time)
self.assertEqual(s1.end_time,
drinks_u1[0].time + td_10m + SESSION_DELTA)
self.assertEqual(s1.drinks.all().filter(user=u1).count(), 2)
self.assertEqual(s1.drinks.all().filter(user=u2).count(), 1)
# session 2: at time 200, 1 drink
self.assertEqual(s2.start_time, base_time + td_390m)
self.assertEqual(s2.end_time, base_time + td_400m + SESSION_DELTA)
self.assertEqual(s2.drinks.all().filter(user=u1).count(), 1)
self.assertEqual(s2.drinks.all().filter(user=u2).count(), 2)
# user2 session2: drinks are added out of order to create this, ensure times
# match
u2_c2 = u2_chunks[1]
self.assertEqual(u2_c2.start_time, base_time + td_390m)
self.assertEqual(u2_c2.end_time, base_time + td_400m + SESSION_DELTA)
# Now check DrinkingSessions were created correctly; there should be
# two groups capturing all 4 sessions.
all_groups = models.DrinkingSession.objects.all().order_by(
'start_time')
self.assertEqual(len(all_groups), 2)
self.assertEqual(all_groups[0].start_time, base_time)
self.assertEqual(all_groups[0].end_time,
base_time + td_10m + SESSION_DELTA)
self.assertEqual(all_groups[0].user_chunks.all().count(), 2)
self.assertEqual(all_groups[1].start_time, base_time + td_390m)
self.assertEqual(all_groups[1].end_time,
base_time + td_400m + SESSION_DELTA)
self.assertEqual(all_groups[1].user_chunks.all().count(), 2)
def to_pints(volume):
return float(units.Quantity(volume).InPints())
def testDrinkSessions(self):
""" Checks for the DrinkingSession records. """
u1 = self.user
u2 = self.user2
units.Quantity(1200)
base_time = make_datetime(2009, 1, 1, 1, 0, 0)
td_10m = datetime.timedelta(minutes=10)
td_400m = datetime.timedelta(minutes=400)
td_390m = td_400m - td_10m
self.assertEqual(models.Drink.objects.all().count(), 0)
self.assertEqual(models.DrinkingSession.objects.all().count(), 0)
# u=1 t=0
self.backend.record_drink(
self.tap,
ticks=1200,
username=u1.username,
pour_time=base_time,
)
# u=2 t=0
self.backend.record_drink(
self.tap,
ticks=1200,
username=u2.username,
pour_time=base_time,
)
# u=1 t=10
self.backend.record_drink(
self.tap,
ticks=1200,
username=u1.username,
pour_time=base_time + td_10m,
)
# u=1 t=400
self.backend.record_drink(
self.tap,
ticks=1200,
username=u1.username,
pour_time=base_time + td_400m,
)
# u=2 t=490
self.backend.record_drink(
self.tap,
ticks=1200,
username=u2.username,
pour_time=base_time + td_390m,
)
# u=2 t=400
self.backend.record_drink(
self.tap,
ticks=1200,
username=u2.username,
pour_time=base_time + td_400m,
)
drinks_u1 = u1.drinks.all().order_by('time')
s1, s2 = models.DrinkingSession.objects.all().order_by(
'start_time')[:2]
SESSION_DELTA = datetime.timedelta(
minutes=kb_common.DRINK_SESSION_TIME_MINUTES)
# session 1: should be 10 minutes long as created above
self.assertEqual(s1.start_time, drinks_u1[0].time)
self.assertEqual(s1.end_time,
drinks_u1[0].time + td_10m + SESSION_DELTA)
self.assertEqual(s1.drinks.all().filter(user=u1).count(), 2)
self.assertEqual(s1.drinks.all().filter(user=u2).count(), 1)
# session 2: at time 200, 1 drink
self.assertEqual(s2.start_time, base_time + td_390m)
self.assertEqual(s2.end_time, base_time + td_400m + SESSION_DELTA)
self.assertEqual(s2.drinks.all().filter(user=u1).count(), 1)
self.assertEqual(s2.drinks.all().filter(user=u2).count(), 2)
# Now check DrinkingSessions were created correctly; there should be
# two groups capturing all 4 sessions.
all_groups = models.DrinkingSession.objects.all().order_by(
'start_time')
self.assertEqual(len(all_groups), 2)
self.assertEqual(all_groups[0].start_time, base_time)
self.assertEqual(all_groups[0].end_time,
base_time + td_10m + SESSION_DELTA)
self.assertEqual(all_groups[1].start_time, base_time + td_390m)
self.assertEqual(all_groups[1].end_time,
base_time + td_400m + SESSION_DELTA)
self.assertEqual("kb_tester2 and kb_tester", s2.summarize_drinkers())
