def test_privacy(self):
b = get_kegbot_backend()
keg = b.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
producer_name="Unknown",
beverage_type="beer",
style_name="Unknown",
)
self.assertIsNotNone(keg)
d = b.record_drink("kegboard.flow0", ticks=100)
# URLs to expected contents
urls = {
"/kegs/": "Keg List",
"/stats/": "System Stats",
"/sessions/": "All Sessions",
"/kegs/{}".format(keg.id): "Keg {}".format(keg.id),
"/drinks/{}".format(d.id): "Drink {}".format(d.id),
}
def test_urls(expect_fail, urls=urls):
for url, expected_content in urls.iteritems():
response = self.client.get(url)
if expect_fail:
self.assertNotContains(response, expected_content, status_code=401, msg_prefix=url)
else:
self.assertContains(response, expected_content, status_code=200, msg_prefix=url)
b = get_kegbot_backend()
user = b.create_new_user("testuser", "*****@*****.**", password="******")
kbsite = models.KegbotSite.get()
self.client.logout()
# Public mode.
test_urls(expect_fail=False)
# Members-only.
kbsite.privacy = "members"
kbsite.save()
test_urls(expect_fail=True)
logged_in = self.client.login(username="******", password="******")
self.assertTrue(logged_in)
test_urls(expect_fail=False)
# Staff-only
kbsite.privacy = "staff"
kbsite.save()
test_urls(expect_fail=True)
user.is_staff = True
user.save()
test_urls(expect_fail=False)
self.client.logout()
test_urls(expect_fail=True)
def test_privacy(self):
b = get_kegbot_backend()
keg = b.start_keg('kegboard.flow0', beverage_name='Unknown', producer_name='Unknown',
beverage_type='beer', style_name='Unknown')
self.assertIsNotNone(keg)
d = b.record_drink('kegboard.flow0', ticks=100)
drink_id = d.id
# URLs to expected contents
urls = {
'/kegs/': 'Keg List',
'/stats/': 'System Stats',
'/sessions/': 'All Sessions',
'/kegs/{}'.format(keg.id): 'Keg {}'.format(keg.id),
'/drinks/{}'.format(d.id): 'Drink {}'.format(d.id),
}
def test_urls(expect_fail, urls=urls):
for url, expected_content in urls.iteritems():
response = self.client.get(url)
if expect_fail:
self.assertNotContains(response, expected_content, status_code=401,
msg_prefix=url)
else:
self.assertContains(response, expected_content, status_code=200,
msg_prefix=url)
b = get_kegbot_backend()
user = b.create_new_user('testuser', '*****@*****.**', password='******')
kbsite = models.KegbotSite.get()
self.client.logout()
# Public mode.
test_urls(expect_fail=False)
# Members-only.
kbsite.privacy = 'members'
kbsite.save()
test_urls(expect_fail=True)
logged_in = self.client.login(username='******', password='******')
self.assertTrue(logged_in)
test_urls(expect_fail=False)
# Staff-only
kbsite.privacy = 'staff'
kbsite.save()
test_urls(expect_fail=True)
user.is_staff = True
user.save()
test_urls(expect_fail=False)
self.client.logout()
test_urls(expect_fail=True)
def testBasicEndpoints(self):
for endpoint in ('/kegs/', '/stats/'):
response = self.client.get(endpoint)
self.assertEquals(200, response.status_code)
for endpoint in ('/sessions/',):
response = self.client.get(endpoint)
self.assertEquals(404, response.status_code)
b = get_kegbot_backend()
keg = b.start_keg('kegboard.flow0', beverage_name='Unknown', producer_name='Unknown',
beverage_type='beer', style_name='Unknown')
self.assertIsNotNone(keg)
response = self.client.get('/kegs/')
self.assertEquals(200, response.status_code)
d = b.record_drink('kegboard.flow0', ticks=100)
drink_id = d.id
response = self.client.get('/d/%s' % drink_id, follow=True)
self.assertRedirects(response, '/drinks/%s' % drink_id, status_code=301)
session_id = d.session.id
response = self.client.get('/s/%s' % session_id, follow=True)
self.assertRedirects(response, d.session.get_absolute_url(), status_code=301)
def process_request(self, request):
epoch = None
request.need_setup = False
request.need_upgrade = False
request.kbsite = None
# Select only the `epoch` column, as pending database migrations could
# make a full select crash.
rows = models.KegbotSite.objects.filter(name='default').values('epoch')
if not rows:
request.need_setup = True
elif rows[0].get('epoch', 0) < EPOCH:
request.need_upgrade = True
else:
request.kbsite = models.KegbotSite.objects.get(name='default')
if request.kbsite.is_setup:
timezone.activate(request.kbsite.timezone)
request.plugins = dict((p.get_short_name(), p) for p in plugin_util.get_plugins())
else:
request.need_setup = True
request.kbcache = KegbotCache()
request.backend = get_kegbot_backend()
return None
def testShout(self):
b = get_kegbot_backend()
keg = b.start_keg('kegboard.flow0', beverage_name='Unknown', producer_name='Unknown',
beverage_type='beer', style_name='Unknown')
d = b.record_drink('kegboard.flow0', ticks=123, shout='_UNITTEST_')
response = self.client.get(d.get_absolute_url())
self.assertContains(response, '<p>_UNITTEST_</p>', status_code=200)
def save(self, tap):
if not self.is_valid():
raise ValueError('Form is not valid.')
b = get_kegbot_backend()
if tap.is_active():
b.end_keg(tap.current_keg)
keg_size = self.cleaned_data.get('keg_size')
full_volume_ml = self.cleaned_data.get('full_volume_ml')
if keg_size != 'other':
full_volume_ml = None
else:
full_volume_ml = self.cleaned_data.get('initial_volume')
# TODO(mikey): Support non-beer beverage types.
cd = self.cleaned_data
keg = b.start_keg(tap, beverage_name=cd['beverage_name'], producer_name=cd['producer_name'],
beverage_type='beer', style_name=cd['style_name'], keg_type=cd['keg_size'],
full_volume_ml=full_volume_ml)
if cd.get('description'):
keg.description = cd['description']
keg.save()
def testBasicEndpoints(self):
for endpoint in ("/kegs/", "/stats/", "/drinkers/guest/", "/drinkers/guest/sessions/"):
response = self.client.get(endpoint)
self.assertEquals(200, response.status_code)
for endpoint in ("/sessions/",):
response = self.client.get(endpoint)
self.assertEquals(404, response.status_code)
b = get_kegbot_backend()
keg = b.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
producer_name="Unknown",
beverage_type="beer",
style_name="Unknown",
)
self.assertIsNotNone(keg)
response = self.client.get("/kegs/")
self.assertEquals(200, response.status_code)
d = b.record_drink("kegboard.flow0", ticks=100)
drink_id = d.id
response = self.client.get("/d/%s" % drink_id, follow=True)
self.assertRedirects(response, "/drinks/%s" % drink_id, status_code=301)
session_id = d.session.id
response = self.client.get("/s/%s" % session_id, follow=True)
self.assertRedirects(response, d.session.get_absolute_url(), status_code=301)
def save(self, commit=True):
if not commit:
raise ValueError('TapForm does not support commit=False')
instance = super(TapForm, self).save(commit=True)
b = get_kegbot_backend()
b.connect_meter(instance, self.cleaned_data['meter'])
b.connect_toggle(instance, self.cleaned_data['toggle'])
return instance
def save(self, commit=True):
if not commit:
raise ValueError("TapForm does not support commit=False")
instance = super(TapForm, self).save(commit=True)
b = get_kegbot_backend()
b.connect_meter(instance, self.cleaned_data["meter"])
b.connect_toggle(instance, self.cleaned_data["toggle"])
return instance
def register(request):
context = RequestContext(request)
form = KegbotRegistrationForm()
# Check if we need an invitation before processing the request further.
invite = None
if request.kbsite.registration_mode != 'public':
invite_code = None
if 'invite_code' in request.GET:
invite_code = request.GET['invite_code']
request.session['invite_code'] = invite_code
else:
invite_code = request.session.get('invite_code', None)
if not invite_code:
r = render_to_response('registration/invitation_required.html',
context_instance=context)
r.status_code = 401
return r
try:
invite = models.Invitation.objects.get(invite_code=invite_code)
except models.Invitation.DoesNotExist:
pass
if not invite or invite.is_expired():
r = render_to_response('registration/invitation_expired.html',
context_instance=context)
r.status_code = 401
return r
if request.method == 'POST':
form = KegbotRegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data.get('password1')
backend = get_kegbot_backend()
backend.create_new_user(username=username, email=email, password=password)
if invite:
invite.delete()
if 'invite_code' in request.session:
del request.session['invite_code']
if password:
new_user = authenticate(username=username, password=password)
login(request, new_user)
return redirect('kb-account-main')
return render_to_response('registration/registration_complete.html',
context_instance=context)
context['form'] = form
return render_to_response('registration/registration_form.html',
context_instance=context)
def __call__(self, request):
if request.kbsite and not request.need_setup:
timezone.activate(request.kbsite.timezone)
request.plugins = dict(
(p.get_short_name(), p)
for p in list(plugin_util.get_plugins().values()))
request.backend = get_kegbot_backend()
return self.get_response(request)
def testShout(self):
b = get_kegbot_backend()
b.start_keg('kegboard.flow0',
beverage_name='Unknown',
producer_name='Unknown',
beverage_type='beer',
style_name='Unknown')
d = b.record_drink('kegboard.flow0', ticks=123, shout='_UNITTEST_')
response = self.client.get(d.get_absolute_url())
self.assertContains(response, '<p>_UNITTEST_</p>', status_code=200)
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True)
self.user = core_models.User.objects.create(
username='******', email='*****@*****.**')
# Password reset requires a usable password.
self.user.set_password('1234')
self.user.save()
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True)
self.user = core_models.User.objects.create(username='******',
email='*****@*****.**')
# Password reset requires a usable password.
self.user.set_password('1234')
self.user.save()
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True, create_controller=True)
self.user = models.User.objects.create(username='******',
email='test@example')
self.prefs = models.NotificationSettings.objects.create(user=self.user,
backend='pykeg.notification.backends.email.EmailNotificationBackend',
keg_tapped=False, session_started=False, keg_volume_low=False,
keg_ended=False)
def testShout(self):
b = get_kegbot_backend()
b.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
producer_name="Unknown",
beverage_type="beer",
style_name="Unknown",
)
d = b.record_drink("kegboard.flow0", ticks=123, shout="_UNITTEST_")
response = self.client.get(d.get_absolute_url())
self.assertContains(response, "<p>_UNITTEST_</p>", status_code=200)
def register(request):
context = RequestContext(request)
form = KegbotRegistrationForm()
# Check if we need an invitation before processing the request further.
invite = None
if request.kbsite.registration_mode != "public":
invite_code = None
if "invite_code" in request.GET:
invite_code = request.GET["invite_code"]
request.session["invite_code"] = invite_code
else:
invite_code = request.session.get("invite_code", None)
if not invite_code:
r = render_to_response("registration/invitation_required.html", context_instance=context)
r.status_code = 401
return r
try:
invite = models.Invitation.objects.get(invite_code=invite_code)
except models.Invitation.DoesNotExist:
pass
if not invite or invite.is_expired():
r = render_to_response("registration/invitation_expired.html", context_instance=context)
r.status_code = 401
return r
if request.method == "POST":
form = KegbotRegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
email = form.cleaned_data["email"]
password = form.cleaned_data.get("password1")
backend = get_kegbot_backend()
backend.create_new_user(username=username, email=email, password=password)
if invite:
invite.delete()
if "invite_code" in request.session:
del request.session["invite_code"]
if password:
new_user = authenticate(username=username, password=password)
login(request, new_user)
return redirect("kb-account-main")
return render_to_response("registration/registration_complete.html", context_instance=context)
context["form"] = form
return render_to_response("registration/registration_form.html", context_instance=context)
def setUp(self):
models.KegbotSite.get() # create the site
self.backend = get_kegbot_backend()
self.producer = models.BeverageProducer.objects.create(
name='Moonshine Beers',
country='USA',
origin_state='Anystate',
origin_city='Bathtub',
url='http://example.com/',
description='Pretty bad beers.',
)
self.beverage = models.Beverage.objects.create(
name='Moonshine Porter',
producer=self.producer,
style='Porter',
calories_per_ml=3.0,
carbs_per_ml=10.0,
abv_percent=0.05,
)
self.keg = models.Keg.objects.create(
type=self.beverage,
keg_type='other',
start_time=make_datetime(2000, 4, 1),
end_time=make_datetime(2000, 5, 1),
description='Our first keg!',
full_volume_ml=2000,
)
self.tap = models.KegTap.objects.create(
name='Test Tap',
current_keg=self.keg,
)
self.controller = models.Controller.objects.create(
name='kegboard'
)
self.meter = models.FlowMeter.objects.create(
controller=self.controller,
port_name='flow0',
ticks_per_ml=2.2,
tap=self.tap
)
self.user = models.User.objects.create(
username='******',
)
self.user2 = models.User.objects.create(
username='******',
)
def testShout(self):
b = get_kegbot_backend()
b.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
producer_name="Unknown",
beverage_type="beer",
style_name="Unknown",
)
d = b.record_drink("kegboard.flow0", ticks=123, shout="_UNITTEST_")
response = self.client.get(d.get_absolute_url())
self.assertContains(response, "<p>_UNITTEST_</p>", status_code=200)
def setUp(self):
models.KegbotSite.get() # create the site
self.backend = get_kegbot_backend()
self.producer = models.BeverageProducer.objects.create(
name='Moonshine Beers',
country='USA',
origin_state='Anystate',
origin_city='Bathtub',
url='http://example.com/',
description='Pretty bad beers.',
)
self.beverage = models.Beverage.objects.create(
name='Moonshine Porter',
producer=self.producer,
style='Porter',
calories_per_ml=3.0,
carbs_per_ml=10.0,
abv_percent=0.05,
)
self.keg = models.Keg.objects.create(
type=self.beverage,
keg_type='other',
start_time=make_datetime(2000, 4, 1),
end_time=make_datetime(2000, 5, 1),
description='Our first keg!',
full_volume_ml=2000,
)
self.tap = models.KegTap.objects.create(
name='Test Tap',
current_keg=self.keg,
)
self.controller = models.Controller.objects.create(
name='kegboard'
)
self.meter = models.FlowMeter.objects.create(
controller=self.controller,
port_name='flow0',
ticks_per_ml=2.2,
tap=self.tap
)
self.user = models.User.objects.create(
username='******',
)
self.user2 = models.User.objects.create(
username='******',
)
def save(
self,
domain_override=None,
subject_template_name="registration/password_reset_subject.txt",
email_template_name="registration/password_reset_email.html",
use_https=False,
token_generator=default_token_generator,
from_email=None,
request=None,
html_email_template_name=None,
extra_email_context=None,
):
"""
Generates a one-use only link for resetting password and sends to the
user.
"""
from django.core.mail import send_mail
email = self.cleaned_data["email"]
active_users = User._default_manager.filter(email__iexact=email,
is_active=True)
for user in active_users:
# Make sure that no email is sent to a user that actually has
# a password marked as unusable
if not user.has_usable_password():
continue
from_email = settings.DEFAULT_FROM_EMAIL or from_email
be = get_kegbot_backend()
base_url = be.get_base_url()
parsed = urllib.parse.urlparse(base_url)
domain = parsed.netloc
protocol = parsed.scheme
kbsite = models.KegbotSite.get()
site_name = kbsite.title
c = {
"email": user.email,
"site_name": site_name,
"uid": urlsafe_base64_encode(force_bytes(user.pk)),
"user": user,
"token": token_generator.make_token(user),
"domain": domain,
"protocol": protocol,
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = "".join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject, email, from_email, [user.email])
def setUp(self):
self.backend = get_kegbot_backend()
models.User.objects.create_user('guest')
test_usernames = ('user1', 'user2', 'user3')
self.users = [self.backend.create_new_user(name, '*****@*****.**' % name) for name in test_usernames]
self.taps = [
self.backend.create_tap('tap1', 'kegboard.flow0', ticks_per_ml=2.2),
self.backend.create_tap('tap2', 'kegboard.flow1', ticks_per_ml=2.2),
]
self.keg = self.backend.start_keg('kegboard.flow0', beverage_name='Unknown',
beverage_type='beer', producer_name='Unknown', style_name='Unknown')
def save(self):
if not self.is_valid():
raise ValueError('Form is not valid.')
keg_size = self.cleaned_data.get('keg_size')
if keg_size != 'other':
full_volume_ml = None
else:
full_volume_ml = self.cleaned_data.get('initial_volume')
# TODO(mikey): Support non-beer beverage types.
cd = self.cleaned_data
b = get_kegbot_backend()
keg = b.create_keg(beverage=cd['beverage_name'], keg_type=cd['keg_size'])
return keg
def setUp(self):
self.backend = get_kegbot_backend()
models.User.objects.create_user('guest')
test_usernames = ('user1', 'user2', 'user3')
self.users = [self.backend.create_new_user(name, '*****@*****.**' % name) for name in test_usernames]
self.taps = [
self.backend.create_tap('tap1', 'kegboard.flow0', ticks_per_ml=2.2),
self.backend.create_tap('tap2', 'kegboard.flow1', ticks_per_ml=2.2),
]
self.keg = self.backend.start_keg('kegboard.flow0', beverage_name='Unknown',
beverage_type='beer', producer_name='Unknown', style_name='Unknown')
def setUp(self):
self.datastore = InMemoryDatastore(plugin.FoursquarePlugin.get_short_name())
self.plugin = plugin.FoursquarePlugin(datastore=self.datastore)
self.user = models.User.objects.create(username='******')
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap('Test Tap', 'test.flow0')
self.keg = self.backend.start_keg(tap=self.tap, beverage_name='Test Beer',
beverage_type='beer', producer_name='Test Producer', style_name='Test Style')
fsq_settings = self.plugin.get_site_settings_form()
fsq_settings.cleaned_data = {
'venue_id': '54321',
'client_id': 'fake-client-id',
'client_secret': 'fake-client-secret',
}
self.plugin.save_site_settings_form(fsq_settings)
def setUp(self):
self.datastore = InMemoryDatastore(plugin.UntappdPlugin.get_short_name())
self.fsq = FoursquarePlugin(datastore=self.datastore)
self.fake_plugin_registry = {'foursquare': self.fsq}
self.plugin = plugin.UntappdPlugin(datastore=self.datastore,
plugin_registry=self.fake_plugin_registry)
self.user = models.User.objects.create(username='******')
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap('Test Tap', 'test.flow0')
self.keg = self.backend.start_keg(tap=self.tap, beverage_name='Test Beer',
beverage_type='beer', producer_name='Test Producer', style_name='Test Style')
self.beverage = self.keg.type
self.beverage.untappd_beer_id = '9876'
self.beverage.save()
def save(
self,
domain_override=None,
subject_template_name="registration/password_reset_subject.txt",
email_template_name="registration/password_reset_email.html",
use_https=False,
token_generator=default_token_generator,
from_email=None,
request=None,
):
"""
Generates a one-use only link for resetting password and sends to the
user.
"""
from django.core.mail import send_mail
email = self.cleaned_data["email"]
active_users = User._default_manager.filter(email__iexact=email, is_active=True)
for user in active_users:
# Make sure that no email is sent to a user that actually has
# a password marked as unusable
if not user.has_usable_password():
continue
from_email = getattr(settings, "EMAIL_FROM_ADDRESS", from_email)
be = get_kegbot_backend()
base_url = be.get_base_url()
parsed = urlparse.urlparse(base_url)
domain = parsed.netloc
protocol = parsed.scheme
kbsite = models.KegbotSite.get()
site_name = kbsite.title
c = {
"email": user.email,
"site_name": site_name,
"uid": urlsafe_base64_encode(force_bytes(user.pk)),
"user": user,
"token": token_generator.make_token(user),
"domain": domain,
"protocol": protocol,
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = "".join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject, email, from_email, [user.email])
def setUp(self):
models.KegbotSite.get() # create the site
self.backend = get_kegbot_backend()
self.producer = models.BeverageProducer.objects.create(
name="Moonshine Beers",
country="USA",
origin_state="Anystate",
origin_city="Bathtub",
url="http://example.com/",
description="Pretty bad beers.",
)
self.beverage = models.Beverage.objects.create(
name="Moonshine Porter",
producer=self.producer,
style="Porter",
calories_per_ml=3.0,
carbs_per_ml=10.0,
abv_percent=0.05,
)
self.keg = models.Keg.objects.create(
type=self.beverage,
keg_type="other",
start_time=make_datetime(2000, 4, 1),
end_time=make_datetime(2000, 5, 1),
description="Our first keg!",
full_volume_ml=2000,
)
self.tap = models.KegTap.objects.create(
name="Test Tap",
current_keg=self.keg,
)
self.controller = models.Controller.objects.create(name="kegboard")
self.meter = models.FlowMeter.objects.create(
controller=self.controller,
port_name="flow0",
ticks_per_ml=2.2,
tap=self.tap)
self.user = models.User.objects.create(username="******", )
self.user2 = models.User.objects.create(username="******", )
def user_twitter_redirect(request):
if 'submit-remove' in request.POST:
plugin = request.plugins.get('twitter')
plugin.remove_user_profile(request.user)
messages.success(request, 'Removed Twitter account.')
return redirect('account-plugin-settings', plugin_name='twitter')
plugin = request.plugins['twitter']
client = plugin.get_client()
be = get_kegbot_backend()
url = urlparse.urljoin(be.get_base_url(),
reverse('plugin-twitter-user_twitter_callback'))
client.set_callback_url(url)
return do_redirect(request, client, 'account-plugin-settings',
SESSION_KEY_USER_TWITTER)
def test_activation(self):
b = get_kegbot_backend()
kbsite = models.KegbotSite.get()
self.assertEqual("public", kbsite.privacy)
user = b.create_new_user("testuser", "*****@*****.**")
self.assertIsNotNone(user.activation_key)
self.assertFalse(user.has_usable_password())
activation_key = user.activation_key
self.assertIsNotNone(activation_key)
activation_url = reverse("activate-account",
args=(),
kwargs={"activation_key": activation_key})
# Activation works regardless of privacy settings.
self.client.logout()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
kbsite.privacy = "staff"
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
kbsite.privacy = "members"
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
# Activate the account.
form_data = {
"password": "******",
"password2": "123",
}
response = self.client.post(activation_url,
data=form_data,
follow=True)
self.assertContains(response,
"Your account has been activated!",
status_code=200)
user = models.User.objects.get(pk=user.id)
self.assertIsNone(user.activation_key)
def test_activation(self):
b = get_kegbot_backend()
kbsite = models.KegbotSite.get()
self.assertEqual('public', kbsite.privacy)
user = b.create_new_user('testuser', '*****@*****.**')
self.assertIsNotNone(user.activation_key)
self.assertFalse(user.has_usable_password())
activation_key = user.activation_key
self.assertIsNotNone(activation_key)
activation_url = reverse('activate-account',
args=(),
kwargs={'activation_key': activation_key})
# Activation works regardless of privacy settings.
self.client.logout()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
kbsite.privacy = 'staff'
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
kbsite.privacy = 'members'
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
# Activate the account.
form_data = {
'password': '******',
'password2': '123',
}
response = self.client.post(activation_url,
data=form_data,
follow=True)
self.assertContains(response,
'Your account has been activated!',
status_code=200)
user = models.User.objects.get(pk=user.id)
self.assertIsNone(user.activation_key)
def save(self,
domain_override=None,
subject_template_name='registration/password_reset_subject.txt',
email_template_name='registration/password_reset_email.html',
use_https=False,
token_generator=default_token_generator,
from_email=None,
request=None):
"""
Generates a one-use only link for resetting password and sends to the
user.
"""
from django.core.mail import send_mail
email = self.cleaned_data["email"]
active_users = User._default_manager.filter(email__iexact=email,
is_active=True)
for user in active_users:
# Make sure that no email is sent to a user that actually has
# a password marked as unusable
if not user.has_usable_password():
continue
from_email = getattr(settings, 'EMAIL_FROM_ADDRESS', from_email)
be = get_kegbot_backend()
base_url = be.get_base_url()
parsed = urlparse.urlparse(base_url)
domain = parsed.netloc
protocol = parsed.scheme
kbsite = models.KegbotSite.get()
site_name = kbsite.title
c = {
'email': user.email,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'token': token_generator.make_token(user),
'domain': domain,
'protocol': protocol,
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject, email, from_email, [user.email])
def save(self):
if not self.is_valid():
raise ValueError('Form is not valid.')
b = get_kegbot_backend()
keg_size = self.cleaned_data.get('keg_size')
notes = self.cleaned_data.get('notes')
description = self.cleaned_data.get('description')
if keg_size != 'other':
full_volume_ml = None
else:
full_volume_ml = self.cleaned_data.get('initial_volume')
# TODO(mikey): Support non-beer beverage types.
cd = self.cleaned_data
keg = b.add_keg(beverage_name=cd['beverage_name'], producer_name=cd['producer_name'],
beverage_type='beer', style_name=cd['style_name'], keg_type=cd['keg_size'],
full_volume_ml=full_volume_ml, notes=cd['notes'], description=cd['description'])
return keg
def setUp(self):
self.backend = get_kegbot_backend()
models.User.objects.create_user("guest")
test_usernames = ("user1", "user2", "user3")
self.users = [self.backend.create_new_user(name, "*****@*****.**" % name) for name in test_usernames]
self.taps = [
self.backend.create_tap("tap1", "kegboard.flow0", ticks_per_ml=2.2),
self.backend.create_tap("tap2", "kegboard.flow1", ticks_per_ml=2.2),
]
self.keg = self.backend.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
beverage_type="beer",
producer_name="Unknown",
style_name="Unknown",
)
def setUp(self):
self.datastore = InMemoryDatastore(
plugin.FoursquarePlugin.get_short_name())
self.plugin = plugin.FoursquarePlugin(datastore=self.datastore)
self.user = models.User.objects.create(username='******')
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap('Test Tap', 'test.flow0')
self.keg = self.backend.start_keg(tap=self.tap,
beverage_name='Test Beer',
beverage_type='beer',
producer_name='Test Producer',
style_name='Test Style')
fsq_settings = self.plugin.get_site_settings_form()
fsq_settings.cleaned_data = {
'venue_id': '54321',
'client_id': 'fake-client-id',
'client_secret': 'fake-client-secret',
}
self.plugin.save_site_settings_form(fsq_settings)
def setUp(self):
self.backend = get_kegbot_backend()
models.User.objects.create_user("guest")
test_usernames = ("user1", "user2", "user3")
self.users = [
self.backend.create_new_user(name, "*****@*****.**" % name) for name in test_usernames
]
self.taps = [
self.backend.create_tap("tap1", "kegboard.flow0", ticks_per_ml=2.2),
self.backend.create_tap("tap2", "kegboard.flow1", ticks_per_ml=2.2),
]
self.keg = self.backend.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
beverage_type="beer",
producer_name="Unknown",
style_name="Unknown",
)
def setUp(self):
self.datastore = InMemoryDatastore(plugin.FoursquarePlugin.get_short_name())
self.plugin = plugin.FoursquarePlugin(datastore=self.datastore)
self.user = models.User.objects.create(username="******")
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap("Test Tap", "test.flow0")
self.keg = self.backend.start_keg(
tap=self.tap,
beverage_name="Test Beer",
beverage_type="beer",
producer_name="Test Producer",
style_name="Test Style",
)
fsq_settings = self.plugin.get_site_settings_form()
fsq_settings.cleaned_data = {
"venue_id": "54321",
"client_id": "fake-client-id",
"client_secret": "fake-client-secret",
}
self.plugin.save_site_settings_form(fsq_settings)
def setUp(self):
self.datastore = InMemoryDatastore(
plugin.UntappdPlugin.get_short_name())
self.fsq = FoursquarePlugin(datastore=self.datastore)
self.fake_plugin_registry = {'foursquare': self.fsq}
self.plugin = plugin.UntappdPlugin(
datastore=self.datastore,
plugin_registry=self.fake_plugin_registry)
self.user = models.User.objects.create(username='******')
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap('Test Tap', 'test.flow0')
self.keg = self.backend.start_keg(tap=self.tap,
beverage_name='Test Beer',
beverage_type='beer',
producer_name='Test Producer',
style_name='Test Style')
self.beverage = self.keg.type
self.beverage.untappd_beer_id = '9876'
self.beverage.save()
def summon_drinker(request):
user = random_item(models.User)
tap = random_item(models.KegTap)
beverage = random_item(models.Beverage)
if not tap or not user or not beverage:
messages.error(request, 'No drinkers are available!')
return redirect('kb-home')
be = get_kegbot_backend()
# End keg if it's near empty.
if tap.current_keg and tap.current_keg.remaining_volume_ml(
) < MIN_KEG_VOLUME_ML:
be.end_keg(tap)
# Start keg if the tap is idle.
if not tap.current_keg:
be.start_keg(tap, beverage=beverage)
volume_ml = random.randint(*RANDOM_POUR_RANGE_ML)
drink = be.record_drink(tap,
ticks=0,
volume_ml=volume_ml,
username=user.username)
pictures = list(models.Picture.objects.filter(user=user))
picture = random.choice(pictures) if pictures else None
if picture:
new_picture = models.Picture.objects.create(image=picture.image,
user=user)
drink.picture = new_picture
drink.save()
message = 'We poked <strong>%s</strong>, who just poured <a href="%s">Drink %s</a>.' % (
user.username, drink.get_absolute_url(), drink.id)
messages.success(request, SafeString(message))
return redirect('kb-home')
def test_activation(self):
b = get_kegbot_backend()
kbsite = models.KegbotSite.get()
self.assertEqual('public', kbsite.privacy)
user = b.create_new_user('testuser', '*****@*****.**')
self.assertIsNotNone(user.activation_key)
self.assertFalse(user.has_usable_password())
activation_key = user.activation_key
self.assertIsNotNone(activation_key)
activation_url = reverse('activate-account', args=(),
kwargs={'activation_key': activation_key})
# Activation works regardless of privacy settings.
self.client.logout()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
kbsite.privacy = 'staff'
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
kbsite.privacy = 'members'
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, 'Choose a Password', status_code=200)
# Activate the account.
form_data = {
'password': '******',
'password2': '123',
}
response = self.client.post(activation_url, data=form_data, follow=True)
self.assertContains(response, 'Your account has been activated!', status_code=200)
user = models.User.objects.get(pk=user.id)
self.assertIsNone(user.activation_key)
def do_pour(self, user, when, volume_ml, shout, picture_path):
be = get_kegbot_backend()
tap = random_item(models.KegTap)
# End keg if it's near empty.
if tap.current_keg and tap.current_keg.remaining_volume_ml() < volume_ml:
be.end_keg(tap)
# Start keg if the tap is idle.
if not tap.current_keg:
beverage = random_item(models.Beverage)
be.start_keg(tap, beverage=beverage)
drink = be.record_drink(tap, ticks=0, volume_ml=volume_ml,
username=user.username, pour_time=when, shout=shout)
if picture_path:
p = self.create_picture(picture_path, user=user,
session=drink.session, keg=drink.keg)
drink.picture = p
drink.save()
return drink
def do_pour(self, user, when, volume_ml, shout, picture_path):
be = get_kegbot_backend()
tap = random_item(models.KegTap)
# End keg if it's near empty.
if tap.current_keg and tap.current_keg.remaining_volume_ml() < volume_ml:
be.end_keg(tap.current_keg, when=when)
# Start keg if the tap is idle.
if not tap.current_keg:
beverage = random_item(models.Beverage)
be.start_keg(tap, beverage=beverage, when=when)
drink = be.record_drink(tap, ticks=0, volume_ml=volume_ml,
username=user.username, pour_time=when, shout=shout)
if picture_path:
p = self.create_picture(picture_path, user=user,
session=drink.session, keg=drink.keg)
drink.picture = p
drink.save()
return drink
def process_request(self, request):
request.need_setup = False
request.need_upgrade = False
request.kbsite = None
installed_version = models.KegbotSite.get_installed_version()
if installed_version is None:
request.need_setup = True
else:
request.installed_version_string = str(installed_version)
request.need_upgrade = must_upgrade(installed_version, get_version_object())
if not request.need_setup and not request.need_upgrade:
request.kbsite = models.KegbotSite.objects.get(name='default')
if request.kbsite.is_setup:
timezone.activate(request.kbsite.timezone)
request.plugins = dict((p.get_short_name(), p) for p in plugin_util.get_plugins().values())
else:
request.need_setup = True
request.backend = get_kegbot_backend()
return None
def save(self):
if not self.is_valid():
raise ValueError('Form is not valid.')
keg_size = self.cleaned_data.get('keg_size')
if keg_size != 'other':
full_volume_ml = None
else:
full_volume_ml = self.cleaned_data.get('initial_volume')
# TODO(mikey): Support non-beer beverage types.
cd = self.cleaned_data
b = get_kegbot_backend()
keg = b.create_keg(beverage_name=cd['beverage_name'], producer_name=cd['producer_name'],
beverage_type='beer', style_name=cd['style_name'], keg_type=cd['keg_size'],
full_volume_ml=full_volume_ml, notes=cd['notes'], description=cd['description'])
tap = cd['connect_to']
if tap:
if tap.is_active():
b.end_keg(tap.current_keg)
b.attach_keg(tap, keg)
return keg
def process_request(self, request):
request.need_setup = False
request.need_upgrade = False
request.kbsite = None
installed_version = models.KegbotSite.get_installed_version()
if installed_version is None:
request.need_setup = True
else:
request.installed_version_string = str(installed_version)
request.need_upgrade = must_upgrade(installed_version, get_version_object())
if not request.need_setup and not request.need_upgrade:
request.kbsite = models.KegbotSite.objects.get(name='default')
if request.kbsite.is_setup:
timezone.activate(request.kbsite.timezone)
request.plugins = dict((p.get_short_name(), p) for p in plugin_util.get_plugins().values())
else:
request.need_setup = True
request.backend = get_kegbot_backend()
return None
def setUp(self):
self.datastore = InMemoryDatastore(
plugin.UntappdPlugin.get_short_name())
self.fsq = FoursquarePlugin(datastore=self.datastore)
self.fake_plugin_registry = {"foursquare": self.fsq}
self.plugin = plugin.UntappdPlugin(
datastore=self.datastore,
plugin_registry=self.fake_plugin_registry)
self.user = models.User.objects.create(username="******")
self.backend = get_kegbot_backend()
self.tap = self.backend.create_tap("Test Tap", "test.flow0")
self.keg = self.backend.start_keg(
tap=self.tap,
beverage_name="Test Beer",
beverage_type="beer",
producer_name="Test Producer",
style_name="Test Style",
)
self.beverage = self.keg.type
self.beverage.untappd_beer_id = "9876"
self.beverage.save()
def summon_drinker(request):
user = random_item(models.User)
tap = random_item(models.KegTap)
beverage = random_item(models.Beverage)
if not tap or not user or not beverage:
messages.error(request, 'No drinkers are available!')
return redirect('kb-home')
be = get_kegbot_backend()
# End keg if it's near empty.
if tap.current_keg and tap.current_keg.remaining_volume_ml() < MIN_KEG_VOLUME_ML:
be.end_keg(tap.current_keg)
# Start keg if the tap is idle.
if not tap.current_keg:
be.start_keg(tap, beverage=beverage)
volume_ml = random.randint(*RANDOM_POUR_RANGE_ML)
drink = be.record_drink(tap, ticks=0, volume_ml=volume_ml,
username=user.username)
pictures = list(models.Picture.objects.filter(user=user))
picture = random.choice(pictures) if pictures else None
if picture:
new_picture = models.Picture.objects.create(image=picture.image,
user=user)
drink.picture = new_picture
drink.save()
message = 'We poked <strong>%s</strong>, who just poured <a href="%s">Drink %s</a>.' % (
user.username, drink.get_absolute_url(), drink.id)
messages.success(request, SafeString(message))
return redirect('kb-home')
def test_activation(self):
b = get_kegbot_backend()
kbsite = models.KegbotSite.get()
self.assertEqual("public", kbsite.privacy)
user = b.create_new_user("testuser", "*****@*****.**")
self.assertIsNotNone(user.activation_key)
self.assertFalse(user.has_usable_password())
activation_key = user.activation_key
self.assertIsNotNone(activation_key)
activation_url = reverse("activate-account", args=(), kwargs={"activation_key": activation_key})
# Activation works regardless of privacy settings.
self.client.logout()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
kbsite.privacy = "staff"
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
kbsite.privacy = "members"
kbsite.save()
response = self.client.get(activation_url)
self.assertContains(response, "Choose a Password", status_code=200)
# Activate the account.
form_data = {"password": "******", "password2": "123"}
response = self.client.post(activation_url, data=form_data, follow=True)
self.assertContains(response, "Your account has been activated!", status_code=200)
user = models.User.objects.get(pk=user.id)
self.assertIsNone(user.activation_key)
def url(self, name):
be = get_kegbot_backend()
base_url = be.get_base_url()
if not self.base_url.startswith(base_url):
self.base_url = urllib.parse.urljoin(base_url, self.base_url)
return super(KegbotFileSystemStorage, self).url(name)
def url(self, name):
be = get_kegbot_backend()
base_url = be.get_base_url()
if not self.base_url.startswith(base_url):
self.base_url = urlparse.urljoin(base_url, self.base_url)
return super(KegbotFileSystemStorage, self).url(name)
def test_privacy(self):
b = get_kegbot_backend()
keg = b.start_keg(
"kegboard.flow0",
beverage_name="Unknown",
producer_name="Unknown",
beverage_type="beer",
style_name="Unknown",
)
self.assertIsNotNone(keg)
d = b.record_drink("kegboard.flow0", ticks=100)
# URLs to expected contents
urls = {
"/kegs/": "Keg List",
"/stats/": "System Stats",
"/sessions/": "All Sessions",
"/kegs/{}".format(keg.id): "Keg {}".format(keg.id),
"/drinks/{}".format(d.id): "Drink {}".format(d.id),
}
def test_urls(expect_fail, urls=urls):
for url, expected_content in list(urls.items()):
response = self.client.get(url)
if expect_fail:
self.assertNotContains(response,
expected_content,
status_code=401,
msg_prefix=url)
else:
self.assertContains(response,
expected_content,
status_code=200,
msg_prefix=url)
b = get_kegbot_backend()
user = b.create_new_user("testuser",
"*****@*****.**",
password="******")
kbsite = models.KegbotSite.get()
self.client.logout()
# Public mode.
test_urls(expect_fail=False)
# Members-only.
kbsite.privacy = "members"
kbsite.save()
test_urls(expect_fail=True)
logged_in = self.client.login(username="******", password="******")
self.assertTrue(logged_in)
test_urls(expect_fail=False)
# Staff-only
kbsite.privacy = "staff"
kbsite.save()
test_urls(expect_fail=True)
user.is_staff = True
user.save()
test_urls(expect_fail=False)
self.client.logout()
test_urls(expect_fail=True)
def base_url(self):
"""Returns the base address of this system."""
return get_kegbot_backend().get_base_url()
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True, create_controller=True)
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True)
self.user = models.User.objects.create(username='******',
email='test@example')
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True, create_controller=True)
def register(request):
context = {}
form = KegbotRegistrationForm()
# Check if we need an invitation before processing the request further.
invite = None
if request.kbsite.registration_mode != "public":
invite_code = None
if "invite_code" in request.GET:
invite_code = request.GET["invite_code"]
request.session["invite_code"] = invite_code
else:
invite_code = request.session.get("invite_code", None)
if not invite_code:
r = render(request,
"registration/invitation_required.html",
context=context)
r.status_code = 401
return r
try:
invite = models.Invitation.objects.get(invite_code=invite_code)
except models.Invitation.DoesNotExist:
pass
if not invite or invite.is_expired():
r = render(request,
"registration/invitation_expired.html",
context=context)
r.status_code = 401
return r
if request.method == "POST":
form = KegbotRegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
email = form.cleaned_data["email"]
password = form.cleaned_data.get("password1")
backend = get_kegbot_backend()
backend.create_new_user(username=username,
email=email,
password=password)
if invite:
invite.delete()
if "invite_code" in request.session:
del request.session["invite_code"]
if password:
new_user = authenticate(username=username, password=password)
login(request, new_user)
return redirect("kb-account-main")
return render(request,
"registration/registration_complete.html",
context=context)
context["form"] = form
return render(request,
"registration/registration_form.html",
context=context)
def setUp(self):
self.backend = get_kegbot_backend()
defaults.set_defaults(set_is_setup=True)
self.user = core_models.User.objects.create(
username='******', email='test@example')
