def login_box_raw(request, return_url=None, auth_systems=None):
"""
a chunk of HTML that shows the various login options
"""
if return_url is None:
return_url = reverse('home')
default_auth_system_obj = None
if auth.DEFAULT_AUTH_SYSTEM:
default_auth_system_obj = AUTH_SYSTEMS[auth.DEFAULT_AUTH_SYSTEM]
# make sure that auth_systems includes only available and enabled auth systems
if auth_systems != None:
enabled_auth_systems = set(auth_systems).intersection(
set(auth.ENABLED_AUTH_SYSTEMS)).intersection(
set(AUTH_SYSTEMS.keys()))
else:
enabled_auth_systems = set(auth.ENABLED_AUTH_SYSTEMS).intersection(
set(AUTH_SYSTEMS.keys()))
form = password.LoginForm()
return render_template_raw(
request, 'login_box', {
'enabled_auth_systems': enabled_auth_systems,
'return_url': return_url,
'default_auth_system': auth.DEFAULT_AUTH_SYSTEM,
'default_auth_system_obj': default_auth_system_obj,
'form': form
})
def login_box_raw(request, return_url="/", auth_systems=None):
"""
a chunk of HTML that shows the various login options
"""
default_auth_system_obj = None
if helios_auth.DEFAULT_AUTH_SYSTEM:
default_auth_system_obj = AUTH_SYSTEMS[helios_auth.DEFAULT_AUTH_SYSTEM]
# make sure that auth_systems includes only available and enabled auth systems
if auth_systems != None:
enabled_auth_systems = (
set(auth_systems).intersection(set(helios_auth.ENABLED_AUTH_SYSTEMS)).intersection(set(AUTH_SYSTEMS.keys()))
)
else:
enabled_auth_systems = set(auth.ENABLED_AUTH_SYSTEMS).intersection(set(AUTH_SYSTEMS.keys()))
form = password.LoginForm()
return render_template_raw(
request,
"login_box",
{
"enabled_auth_systems": enabled_auth_systems,
"return_url": return_url,
"default_auth_system": helios_auth.DEFAULT_AUTH_SYSTEM,
"default_auth_system_obj": default_auth_system_obj,
"form": form,
},
)
def test_can_create_election(self):
"""
check that auth systems have the can_create_election call and that it's true for the common ones
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
assert (hasattr(auth_system_module, 'can_create_election'))
if auth_system != 'clever':
assert (auth_system_module.can_create_election('foobar', {}))
def test_can_create_election(self):
"""
check that auth systems have the can_create_election call and that it's true for the common ones
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
assert(hasattr(auth_system_module, 'can_create_election'))
if auth_system != 'clever':
assert(auth_system_module.can_create_election('foobar', {}))
def test_eq(self):
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(
user_type=auth_system, user_id='foobar_eq', info={'name': 'Foo Bar Status Update'})
u2 = models.User.update_or_create(
user_type=auth_system, user_id='foobar_eq', info={'name': 'Foo Bar Status Update'})
self.assertEquals(u, u2)
def can_create_election(self):
"""
Certain auth systems can choose to limit election creation
to certain users.
"""
if not AUTH_SYSTEMS.has_key(self.user_type):
return False
return AUTH_SYSTEMS[self.user_type].can_create_election(self.user_id, self.info)
def send_message(self, subject, body, attachments=[]):
if AUTH_SYSTEMS.has_key(self.user_type):
subject = subject.split("\n")[0]
AUTH_SYSTEMS[self.user_type].send_message(self.user_id,
self.name,
self.info,
subject,
body,
attachments=attachments)
def can_create_election(self):
"""
Certain auth systems can choose to limit election creation
to certain users.
"""
if not AUTH_SYSTEMS.has_key(self.user_type):
return False
return AUTH_SYSTEMS[self.user_type].can_create_election(self.user_id, self.info)
def login_box_raw(request, return_url='/', auth_systems=None):
"""
a chunk of HTML that shows the various login options
"""
default_auth_system_obj = None
if helios_auth.DEFAULT_AUTH_SYSTEM:
default_auth_system_obj = AUTH_SYSTEMS[helios_auth.DEFAULT_AUTH_SYSTEM]
# make sure that auth_systems includes only available and enabled auth systems
if auth_systems != None:
logging.debug('tipo ' + str(type(auth_systems)))
if (type(auth_systems) == type([])
and type(auth_systems[0]) == type({})):
import itertools
l = list(
itertools.chain.from_iterable([d.keys()
for d in auth_systems]))
auth_systems = [
item for pos, item in enumerate(l) if l.index(item) == pos
]
logging.debug('auth_systems ' + str(auth_systems))
logging.debug('helios_auth.ENABLED_AUTH_SYSTEMS ' +
str(helios_auth.ENABLED_AUTH_SYSTEMS))
logging.debug('AUTH_SYSTEMS.keys() ' + str(AUTH_SYSTEMS.keys()))
enabled_auth_systems = set(auth_systems).intersection(
set(helios_auth.ENABLED_AUTH_SYSTEMS)).intersection(
set(AUTH_SYSTEMS.keys()))
logging.debug('enabled_auth_systems ' + str(enabled_auth_systems))
else:
enabled_auth_systems = set(
helios_auth.ENABLED_AUTH_SYSTEMS).intersection(
set(AUTH_SYSTEMS.keys()))
form = password.LoginForm()
return render_template_raw(
request, 'login_box', {
'enabled_auth_systems': enabled_auth_systems,
'return_url': return_url,
'default_auth_system': helios_auth.DEFAULT_AUTH_SYSTEM,
'default_auth_system_obj': default_auth_system_obj,
'form': form
})
def test_eligibility(self):
"""
test that users are reported as eligible for something
FIXME: also test constraints on eligibility
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_status_update', info={'name':'Foo Bar Status Update'})
self.assertTrue(u.is_eligible_for({'auth_system': auth_system}))
def test_eligibility(self):
"""
test that users are reported as eligible for something
FIXME: also test constraints on eligibility
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_status_update', info={'name':'Foo Bar Status Update'})
self.assertTrue(u.is_eligible_for({'auth_system': auth_system}))
def test_unique_users(self):
"""
there should not be two users with the same user_type and user_id
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
models.User.objects.create(user_type = auth_system, user_id = 'foobar', info={'name':'Foo Bar'})
def double_insert():
models.User.objects.create(user_type = auth_system, user_id = 'foobar', info={'name': 'Foo2 Bar'})
self.assertRaises(IntegrityError, double_insert)
transaction.rollback()
def test_status_update(self):
"""
check that a user set up with status update ability reports it as such,
and otherwise does not report it
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_status_update', info={'name':'Foo Bar Status Update'})
if hasattr(auth_system_module, 'send_message'):
self.assertNotEquals(u.update_status_template, None)
else:
self.assertEquals(u.update_status_template, None)
def test_status_update(self):
"""
check that a user set up with status update ability reports it as such,
and otherwise does not report it
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_status_update', info={'name':'Foo Bar Status Update'})
if hasattr(auth_system_module, 'send_message'):
self.assertNotEquals(u.update_status_template, None)
else:
self.assertEquals(u.update_status_template, None)
def test_unique_users(self):
"""
there should not be two users with the same user_type and user_id
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
models.User.objects.create(user_type = auth_system, user_id = 'foobar', info={'name':'Foo Bar'})
def double_insert():
models.User.objects.create(user_type = auth_system, user_id = 'foobar', info={'name': 'Foo2 Bar'})
self.assertRaises(IntegrityError, double_insert)
transaction.rollback()
def test_eq(self):
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(
user_type=auth_system,
user_id='foobar_eq',
info={'name': 'Foo Bar Status Update'})
u2 = models.User.update_or_create(
user_type=auth_system,
user_id='foobar_eq',
info={'name': 'Foo Bar Status Update'})
self.assertEquals(u, u2)
def test_create_or_update(self):
"""
shouldn't create two users, and should reset the password
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_cou', info={'name':'Foo Bar'})
def double_update_or_create():
new_name = 'Foo2 Bar'
u2 = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_cou', info={'name': new_name})
self.assertEquals(u.id, u2.id)
self.assertEquals(u2.info['name'], new_name)
def test_create_or_update(self):
"""
shouldn't create two users, and should reset the password
"""
for auth_system, auth_system_module in AUTH_SYSTEMS.iteritems():
u = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_cou', info={'name':'Foo Bar'})
def double_update_or_create():
new_name = 'Foo2 Bar'
u2 = models.User.update_or_create(user_type = auth_system, user_id = 'foobar_cou', info={'name': new_name})
self.assertEquals(u.id, u2.id)
self.assertEquals(u2.info['name'], new_name)
def login_box_raw(request, return_url='/', auth_systems = None):
"""
a chunk of HTML that shows the various login options
"""
default_auth_system_obj = None
if auth.DEFAULT_AUTH_SYSTEM:
default_auth_system_obj = AUTH_SYSTEMS[auth.DEFAULT_AUTH_SYSTEM]
# make sure that auth_systems includes only available and enabled auth systems
if auth_systems != None:
enabled_auth_systems = set(auth_systems).intersection(set(auth.ENABLED_AUTH_SYSTEMS)).intersection(set(AUTH_SYSTEMS.keys()))
else:
enabled_auth_systems = set(auth.ENABLED_AUTH_SYSTEMS).intersection(set(AUTH_SYSTEMS.keys()))
form = password.LoginForm()
return render_template_raw(request, 'login_box', {
'enabled_auth_systems': enabled_auth_systems, 'return_url': return_url,
'default_auth_system': auth.DEFAULT_AUTH_SYSTEM, 'default_auth_system_obj': default_auth_system_obj,
'form' : form})
def can_update_status(self):
if not AUTH_SYSTEMS.has_key(self.user_type):
return False
return AUTH_SYSTEMS[self.user_type].STATUS_UPDATES
def public_url(self):
if AUTH_SYSTEMS.has_key(self.user_type):
if hasattr(AUTH_SYSTEMS[self.user_type], 'public_url'):
return AUTH_SYSTEMS[self.user_type].public_url(self.user_id)
return None
def send_notification(self, message):
if AUTH_SYSTEMS.has_key(self.user_type):
if hasattr(AUTH_SYSTEMS[self.user_type], 'send_notification'):
AUTH_SYSTEMS[self.user_type].send_notification(
self.user_id, self.info, message)
def update_status(self, status):
if AUTH_SYSTEMS.has_key(self.user_type):
AUTH_SYSTEMS[self.user_type].update_status(self.user_id, self.info,
self.token, status)
def send_message(self, subject, body):
if AUTH_SYSTEMS.has_key(self.user_type):
subject = subject.split("\n")[0]
AUTH_SYSTEMS[self.user_type].send_message(self.user_id, self.name, self.info, subject, body)
def update_status(self, status):
if AUTH_SYSTEMS.has_key(self.user_type):
AUTH_SYSTEMS[self.user_type].update_status(self.user_id, self.info, self.token, status)
def can_update_status(self):
if not AUTH_SYSTEMS.has_key(self.user_type):
return False
return AUTH_SYSTEMS[self.user_type].STATUS_UPDATES
def public_url(self):
if AUTH_SYSTEMS.has_key(self.user_type):
if hasattr(AUTH_SYSTEMS[self.user_type], 'public_url'):
return AUTH_SYSTEMS[self.user_type].public_url(self.user_id)
return None
def send_notification(self, message):
if AUTH_SYSTEMS.has_key(self.user_type):
if hasattr(AUTH_SYSTEMS[self.user_type], 'send_notification'):
AUTH_SYSTEMS[self.user_type].send_notification(self.user_id, self.info, message)
def login_box_raw(request, return_url='/', auth_systems=None, remove_unload=False):
"""
a chunk of HTML that shows the various login options
"""
default_auth_system_obj = None
if helios_auth.DEFAULT_AUTH_SYSTEM:
default_auth_system_obj = AUTH_SYSTEMS[helios_auth.DEFAULT_AUTH_SYSTEM]
# make sure that auth_systems includes only available and enabled
# helios_auth systems
if auth_systems != None:
enabled_auth_systems = set(auth_systems).intersection(set(helios_auth.ENABLED_AUTH_SYSTEMS)).intersection(set(AUTH_SYSTEMS.keys()))
else:
enabled_auth_systems = set(helios_auth.ENABLED_AUTH_SYSTEMS).intersection(set(AUTH_SYSTEMS.keys()))
auth_systems = list()
for auth_system in enabled_auth_systems:
auth_systems.append({'name': auth_system, 'display_name': AUTH_SYSTEMS[auth_system].get_name()})
form = password.LoginForm()
return render_template_raw(request, 'login_box', {
'auth_systems': auth_systems,
'return_url': return_url,
'default_auth_system': helios_auth.DEFAULT_AUTH_SYSTEM,
'default_auth_system_obj': default_auth_system_obj,
'form': form,
'remove_unload': remove_unload
})
