def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Institute, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self,
'Changed %s to %s' % (field, getattr(self, field)))
# update the datastore
from karaage.datastores import machine_category_save_institute
machine_category_save_institute(self)
# has group changed?
if self._tracker.has_changed("group_id"):
old_group_pk = self._tracker.previous("group_id")
new_group = self.group
if old_group_pk is not None:
old_group = Group.objects.get(pk=old_group_pk)
from karaage.datastores import remove_accounts_from_institute
query = Account.objects.filter(person__groups=old_group)
remove_accounts_from_institute(query, self)
if new_group is not None:
from karaage.datastores import add_accounts_to_institute
query = Account.objects.filter(person__groups=new_group)
add_accounts_to_institute(query, self)
def _next(self, request, application, roles, state_key):
""" Continue the state machine at given state. """
# we only support state changes for POST requests
if request.method == "POST":
# If next state is a transition, process it
while isinstance(state_key, Transition):
state_key = state_key.get_next_state(request, application,
roles)
# lookup next state
if state_key not in self._states:
raise RuntimeError("Invalid state '%s'" % state_key)
state, _ = self._states[state_key]
# enter that state
state.enter_state(request, application)
application.state = state_key
application.save()
# log details
log.change(application.application_ptr, "state: %s" % state.name)
# redirect to this new state
url = get_url(request, application, roles)
return HttpResponseRedirect(url)
else:
return HttpResponseBadRequest("<h1>Bad Request</h1>")
def save(self, *args, **kwargs):
super(InstituteDelegate, self).save(*args, **kwargs)
for field in self._tracker.changed():
log.change(
self.institute, 'Delegate %s: Changed %s to %s' %
(self.person, field, getattr(self, field)))
def _next(self, request, application, roles, state_key):
""" Continue the state machine at given state. """
# we only support state changes for POST requests
if request.method == "POST":
# If next state is a transition, process it
while isinstance(state_key, Transition):
state_key = state_key.get_next_state(
request, application, roles)
# lookup next state
if state_key not in self._states:
raise RuntimeError("Invalid state '%s'" % state_key)
state, _ = self._states[state_key]
# enter that state
state.enter_state(request, application)
application.state = state_key
application.save()
# log details
log.change(application.application_ptr, "state: %s" % state.name)
# redirect to this new state
url = get_url(request, application, roles)
return HttpResponseRedirect(url)
else:
return HttpResponseBadRequest("<h1>Bad Request</h1>")
def deactivate(self, deleted_by):
self.is_active = False
self.deleted_by = deleted_by
self.date_deleted = datetime.datetime.today()
self.group.members.clear()
self.save()
log.change(self, 'Deactivated by %s' % deleted_by)
def deactivate(self, deleted_by):
self.is_active = False
self.deleted_by = deleted_by
self.date_deleted = datetime.datetime.today()
self.group.members.clear()
self.save()
log.change(self, 'Deactivated by %s' % deleted_by)
def handle(self, **options):
from karaage.common import log
from karaage.people.models import Person
from django.core.mail import mail_admins
import datetime
today = datetime.date.today()
verbose = int(options.get('verbosity'))
for p in Person.objects.filter(expires__lte=today):
try:
if not p.is_locked():
p.lock()
p.expires = None
p.save()
message = "%s's account has expired and their account " \
"has been locked. %s does not know this" % (p, p)
mail_admins('Locked expired user %s' % p,
message,
fail_silently=False)
log.change(p, 'Account auto expired')
if verbose >= 1:
print("Locked account for %s - %s" % (p.username, p))
except Exception:
print("Failed to lock %s" % p)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Institute, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self, 'Changed %s to %s'
% (field, getattr(self, field)))
# update the datastore
from karaage.datastores import machine_category_save_institute
machine_category_save_institute(self)
# has group changed?
if self._tracker.has_changed("group_id"):
old_group_pk = self._tracker.previous("group_id")
new_group = self.group
if old_group_pk is not None:
old_group = Group.objects.get(pk=old_group_pk)
from karaage.datastores import remove_accounts_from_institute
query = Account.objects.filter(person__groups=old_group)
remove_accounts_from_institute(query, self)
if new_group is not None:
from karaage.datastores import add_accounts_to_institute
query = Account.objects.filter(person__groups=new_group)
add_accounts_to_institute(query, self)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Group, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.field_change(self, field=field, new_value=getattr(self, field))
old_name = self._tracker.previous("name")
new_name = self.name
if old_name is not None and old_name != new_name:
from karaage.datastores import global_set_group_name
global_set_group_name(self, old_name, new_name)
from karaage.datastores import machine_category_set_group_name
machine_category_set_group_name(self, old_name, new_name)
log.change(self, "Renamed group")
# update the datastore
from karaage.datastores import global_save_group
global_save_group(self)
from karaage.datastores import machine_category_save_group
machine_category_save_group(self)
def approve(self, approved_by):
created_person, created_account = \
super(ProjectApplication, self).approve(approved_by)
assert self.applicant is not None
assert self.content_type.model == "person"
person = self.applicant
if self.project is None:
assert self.institute is not None
from karaage.projects.utils import get_new_pid
project = Project(
pid=self.pid or get_new_pid(self.institute),
name=self.name,
description=self.description,
institute=self.institute,
additional_req=self.additional_req,
start_date=datetime.datetime.today(),
end_date=datetime.datetime.today() +
datetime.timedelta(days=365),
)
project.save()
project.activate(approved_by)
self.project = project
self.save()
if self.make_leader:
self.project.leaders.add(person)
if self.needs_account:
if not person.has_account():
log.add(self.application_ptr, 'Created account.')
Account.create(person, self.project)
created_account = True
else:
log.change(self.application_ptr, 'Account already exists')
self.project.group.members.add(person)
return created_person, created_account
def handle(self, **options):
from karaage.common import log
from karaage.people.models import Person
from django.core.mail import mail_admins
import datetime
today = datetime.date.today()
verbose = int(options.get('verbosity'))
for p in Person.objects.filter(expires__lte=today):
try:
if not p.is_locked():
p.lock()
p.expires = None
p.save()
message = "%s's account has expired and their account " \
"has been locked. %s does not know this" % (p, p)
mail_admins(
'Locked expired user %s' % p,
message, fail_silently=False)
log.change(p, 'Account auto expired')
if verbose >= 1:
print("Locked account for %s - %s" % (p.username, p))
except:
print("Failed to lock %s" % p)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Group, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.field_change(self, field=field, new_value=getattr(self, field))
old_name = self._tracker.previous("name")
new_name = self.name
if old_name is not None and old_name != new_name:
from karaage.datastores import global_set_group_name
global_set_group_name(self, old_name, new_name)
from karaage.datastores import machine_category_set_group_name
machine_category_set_group_name(self, old_name, new_name)
log.change(self, "Renamed group")
# update the datastore
from karaage.datastores import global_save_group
global_save_group(self)
from karaage.datastores import machine_category_save_group
machine_category_save_group(self)
def save(self, *args, **kwargs):
super(InstituteDelegate, self).save(*args, **kwargs)
for field in self._tracker.changed():
log.change(
self.institute,
'Delegate %s: Changed %s to %s' %
(self.person, field, getattr(self, field)))
def activate(self, approved_by):
if self.is_active is True:
return
self.is_active = True
self.is_approved = True
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.save()
log.change(self, 'Activated by %s' % approved_by)
def activate(self, approved_by):
if self.is_active is True:
return
self.is_active = True
self.is_approved = True
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.save()
log.change(self, 'Activated by %s' % approved_by)
def save(self, *args, **kwargs):
created = self.pk is None
with transaction.atomic():
# set group if not already set
state = {
'saved': False,
}
if self.group_id is None:
name = self.pid
def pre_save(group, obj, _state=state):
obj.group_id=group.pk
_state['saved'] = True
self.group, _ = Group.objects.get_or_create_unique(
parent=self, name=self.pid,
defaults={'description': self.name},
pre_parent_save=pre_save,
)
if not state['saved']:
# save the object
super(Project, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self, 'Changed %s to %s'
% (field, getattr(self, field)))
# has pid changed?
self._tracker.has_changed("pid")
if self._tracker.has_changed("pid"):
old_pid = self._tracker.previous('pid')
if old_pid is not None:
from karaage.datastores import machine_category_set_project_pid
machine_category_set_project_pid(self, old_pid, self.pid)
log.change(self, 'Renamed %s to %s' % (old_pid, self.pid))
# update the datastore
from karaage.datastores import machine_category_save_project
machine_category_save_project(self)
# has group changed?
if self._tracker.has_changed("group_id"):
old_group_pk = self._tracker.previous("group_id")
new_group = self.group
if old_group_pk is not None:
old_group = Group.objects.get(pk=old_group_pk)
from karaage.datastores import remove_accounts_from_project
query = Account.objects.filter(person__groups=old_group)
remove_accounts_from_project(query, self)
if new_group is not None:
from karaage.datastores import add_accounts_to_project
query = Account.objects.filter(person__groups=new_group)
add_accounts_to_project(query, self)
def activate(self, approved_by):
if not self.is_active:
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.deleted_by = None
self.date_deleted = None
self.is_active = True
self.save()
log.change(self, 'Activated by %s' % approved_by)
def activate(self, approved_by):
if self.is_active is True:
# Call to save() required to keep API consistent.
self.save()
return
self.is_active = True
self.is_approved = True
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.save()
log.change(self, 'Activated by %s' % approved_by)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Software, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self, 'Changed %s to %s'
% (field, getattr(self, field)))
def activate(self, approved_by):
if self.is_active is True:
# Call to save() required to keep API consistent.
self.save()
return
self.is_active = True
self.is_approved = True
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.save()
log.change(self, 'Activated by %s' % approved_by)
def activate(self, approved_by):
if not self.is_active:
self.date_approved = datetime.datetime.today()
self.approved_by = approved_by
self.deleted_by = None
self.date_deleted = None
self.is_active = True
self.save()
log.change(self, 'Activated by %s' % approved_by)
def _person_removed_from_project(sender, instance, *args, **kwargs):
"""
This excecutes when a person is removed from a project.
"""
existing_data = ProjectMembership.objects.get(pk=instance.pk)
project = instance.project
# Log a person being removed from a project
message = '%s was removed from the project.' % instance.person
log.change(project, message)
def approve(self, approved_by):
created_person, created_account = \
super(ProjectApplication, self).approve(approved_by)
assert self.applicant is not None
assert self.content_type.model == "person"
person = self.applicant
if self.project is None:
assert self.institute is not None
from karaage.projects.utils import get_new_pid
project = Project(
pid=self.pid or get_new_pid(self.institute),
name=self.name,
description=self.description,
institute=self.institute,
additional_req=self.additional_req,
start_date=datetime.datetime.today(),
end_date=datetime.datetime.today()
+ datetime.timedelta(days=365),
)
project.save()
for mc in self.machine_categories.all():
project.projectquota_set.create(machine_category=mc)
project.activate(approved_by)
self.project = project
self.save()
if self.make_leader:
self.project.add_update_project_members(
person, is_project_leader=True,
)
if self.needs_account:
found_pc = False
for pc in self.project.projectquota_set.all():
found_pc = True
if not person.has_account(pc.machine_category):
log.add(
self.application_ptr,
'Created account on machine category %s'
% pc.machine_category)
Account.create(person, self.project, pc.machine_category)
created_account = True
else:
log.change(
self.application_ptr,
'Account on machine category %s already exists'
% pc.machine_category)
if not found_pc:
log.change(
self.application_ptr,
'No project quotas found; no accounts created '
'despite being requested')
self.project.group.members.add(person)
return created_person, created_account
def approve(self, approved_by):
created_person, created_account = \
super(ProjectApplication, self).approve(approved_by)
assert self.applicant is not None
assert self.content_type.model == "person"
person = self.applicant
if self.project is None:
assert self.institute is not None
from karaage.projects.utils import get_new_pid
project = Project(
pid=self.pid or get_new_pid(self.institute),
name=self.name,
description=self.description,
institute=self.institute,
additional_req=self.additional_req,
start_date=datetime.datetime.today(),
end_date=datetime.datetime.today() +
datetime.timedelta(days=365),
)
project.save()
for mc in self.machine_categories.all():
project.projectquota_set.create(machine_category=mc)
project.activate(approved_by)
self.project = project
self.save()
if self.make_leader:
self.project.leaders.add(person)
if self.needs_account:
found_pc = False
for pc in self.project.projectquota_set.all():
found_pc = True
if not person.has_account(pc.machine_category):
log.add(
self.application_ptr,
'Created account on machine category %s' %
pc.machine_category)
Account.create(person, self.project, pc.machine_category)
created_account = True
else:
log.change(
self.application_ptr,
'Account on machine category %s already exists' %
pc.machine_category)
if not found_pc:
log.change(
self.application_ptr,
'No project quotas found; no accounts created '
'despite being requested')
self.project.group.members.add(person)
return created_person, created_account
def deactivate(self, deleted_by):
""" Sets Person not active and deletes all Accounts"""
self.is_active = False
self.expires = None
self.date_deleted = datetime.datetime.today()
self.deleted_by = deleted_by
self.groups.clear()
self.save()
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.deactivate()
log.change(self, 'Deactivated by %s' % deleted_by)
def deactivate(self, deleted_by):
""" Sets Person not active and deletes all Accounts"""
self.is_active = False
self.expires = None
self.date_deleted = datetime.datetime.today()
self.deleted_by = deleted_by
self.groups.clear()
self.save()
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.deactivate()
log.change(self, 'Deactivated by %s' % deleted_by)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Person, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
if field != "password":
log.change(
self,
'Changed %s to %s' % (field, getattr(self, field)))
# update datastores
from karaage.datastores import save_account
for ua in self.account_set.filter(date_deleted__isnull=True):
save_account(ua)
# has locked status changed?
if self._tracker.has_changed("login_enabled"):
if self.login_enabled:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.unlock()
else:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.lock()
# has the institute changed?
if self._tracker.has_changed("institute_id"):
from karaage.institutes.models import Institute
old_institute_pk = self._tracker.previous("institute_id")
new_institute = self.institute
if old_institute_pk is not None:
old_institute = Institute.objects.get(pk=old_institute_pk)
from karaage.datastores import remove_accounts_from_institute
query = self.account_set
remove_accounts_from_institute(query, old_institute)
if new_institute is not None:
from karaage.datastores import add_accounts_to_institute
query = self.account_set
add_accounts_to_institute(query, new_institute)
if self._raw_password is not None:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.set_password(self._raw_password)
ua.save()
log.change(self, 'Changed Password')
self._raw_password = None
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Person, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
if field != "password":
log.change(
self,
'Changed %s to %s' % (field, getattr(self, field)))
# update datastores
from karaage.datastores import save_account
for ua in self.account_set.filter(date_deleted__isnull=True):
save_account(ua)
# has locked status changed?
if self._tracker.has_changed("login_enabled"):
if self.login_enabled:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.unlock()
else:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.lock()
# has the institute changed?
if self._tracker.has_changed("institute_id"):
from karaage.institutes.models import Institute
old_institute_pk = self._tracker.previous("institute_id")
new_institute = self.institute
if old_institute_pk is not None:
old_institute = Institute.objects.get(pk=old_institute_pk)
from karaage.datastores import remove_accounts_from_institute
query = self.account_set
remove_accounts_from_institute(query, old_institute)
if new_institute is not None:
from karaage.datastores import add_accounts_to_institute
query = self.account_set
add_accounts_to_institute(query, new_institute)
if self._raw_password is not None:
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.set_password(self._raw_password)
ua.save()
log.change(self, 'Changed Password')
self._raw_password = None
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Machine, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
if field == "password":
log.change(self, 'Changed %s' % field)
else:
log.change(
self,
'Changed %s to %s' % (field, getattr(self, field)))
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(MachineCategory, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(
self, 'Changed %s to %s' % (field, getattr(self, field)))
# check if datastore changed
if self._tracker.has_changed("datastore"):
old_datastore = self._tracker.previous("datastore")
from karaage.datastores import set_mc_datastore
set_mc_datastore(self, old_datastore, self)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(MachineCategory, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self,
'Changed %s to %s' % (field, getattr(self, field)))
# check if datastore changed
if self._tracker.has_changed("datastore"):
old_datastore = self._tracker.previous("datastore")
from karaage.datastores import set_mc_datastore
set_mc_datastore(self, old_datastore, self)
def save(self, *args, **kwargs):
created = self.pk is None
if not self.pk:
self.created_by = get_current_person()
self.expires = datetime.datetime.now() + datetime.timedelta(days=7)
parent = list(self._meta.parents.keys())[0]
subclasses = parent._meta.get_all_related_objects()
for klass in subclasses:
if isinstance(klass, RelatedObject) and klass.field.primary_key and klass.opts == self._meta:
self._class = klass.get_accessor_name()
break
super(Application, self).save(*args, **kwargs)
if created:
log.add(self, "Created")
for field in self._tracker.changed():
log.change(self, "Changed %s to %s" % (field, getattr(self, field)))
def deactivate(self, deleted_by):
""" Sets Person not active and deletes all Accounts"""
# deactivate accounts first, so we don't need to repeatedly update
# their datastores uselessly when clearing the groups.
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.deactivate()
# now we can clear the groups
self.groups.clear()
# finally, mark the person as deleted.
self.is_active = False
self.expires = None
self.date_deleted = datetime.datetime.today()
self.deleted_by = deleted_by
self.save()
# log a message
log.change(self, 'Deactivated by %s' % deleted_by)
def save(self, *args, **kwargs):
created = self.pk is None
# set group if not already set
if self.group_id is None:
name = self.pid
self.group, _ = Group.objects.get_or_create(name=name)
# save the object
super(Project, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self,
'Changed %s to %s' % (field, getattr(self, field)))
# has pid changed?
self._tracker.has_changed("pid")
if self._tracker.has_changed("pid"):
old_pid = self._tracker.previous('pid')
if old_pid is not None:
from karaage.datastores import set_project_pid
set_project_pid(self, old_pid, self.pid)
log.change(self, 'Renamed %s to %s' % (old_pid, self.pid))
# update the datastore
from karaage.datastores import save_project
save_project(self)
# has group changed?
if self._tracker.has_changed("group_id"):
old_group_pk = self._tracker.previous("group_id")
new_group = self.group
if old_group_pk is not None:
old_group = Group.objects.get(pk=old_group_pk)
from karaage.datastores import remove_accounts_from_project
query = Account.objects.filter(person__groups=old_group)
remove_accounts_from_project(query, self)
if new_group is not None:
from karaage.datastores import add_accounts_to_project
query = Account.objects.filter(person__groups=new_group)
add_accounts_to_project(query, self)
def deactivate(self, deleted_by):
""" Sets Person not active and deletes all Accounts"""
# deactivate accounts first, so we don't need to repeatedly update
# their datastores uselessly when clearing the groups.
for ua in self.account_set.filter(date_deleted__isnull=True):
ua.deactivate()
# now we can clear the groups
self.groups.clear()
# finally, mark the person as deleted.
self.is_active = False
self.expires = None
self.date_deleted = datetime.datetime.today()
self.deleted_by = deleted_by
self.save()
# log a message
log.change(self, 'Deactivated by %s' % deleted_by)
def save(self, *args, **kwargs):
created = self.pk is None
# set group if not already set
if self.group_id is None:
name = self.pid
self.group, _ = Group.objects.get_or_create(name=name)
# save the object
super(Project, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self, 'Changed %s to %s'
% (field, getattr(self, field)))
# has pid changed?
self._tracker.has_changed("pid")
if self._tracker.has_changed("pid"):
old_pid = self._tracker.previous('pid')
if old_pid is not None:
from karaage.datastores import set_project_pid
set_project_pid(self, old_pid, self.pid)
log.change(self, 'Renamed %s to %s' % (old_pid, self.pid))
# update the datastore
from karaage.datastores import save_project
save_project(self)
# has group changed?
if self._tracker.has_changed("group_id"):
old_group_pk = self._tracker.previous("group_id")
new_group = self.group
if old_group_pk is not None:
old_group = Group.objects.get(pk=old_group_pk)
from karaage.datastores import remove_accounts_from_project
query = Account.objects.filter(person__groups=old_group)
remove_accounts_from_project(query, self)
if new_group is not None:
from karaage.datastores import add_accounts_to_project
query = Account.objects.filter(person__groups=new_group)
add_accounts_to_project(query, self)
def save(self, *args, **kwargs):
created = self.pk is None
if not self.expires:
self.expires = datetime.datetime.now() + datetime.timedelta(days=7)
if not self.pk:
self.created_by = get_current_person()
# Find the accessor from Application to type(self) class
if hasattr(Application._meta, 'get_fields'):
# Django >= 1.8
fields = [
f for f in Application._meta.get_fields()
if isinstance(f, OneToOneRel) and
f.field.primary_key and
f.auto_created
]
else:
# Django <= 1.8
fields = [
f for f in Application._meta.get_all_related_objects()
if isinstance(f, OneToOneRel) and
f.field.primary_key
]
for rel in fields:
# Works with Django < 1.8 and => 1.8
related_model = getattr(rel, 'related_model', rel.model)
# if we find it, save the name
if related_model == type(self):
self._class = rel.get_accessor_name()
break
super(Application, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(
self,
'Changed %s to %s' % (field, getattr(self, field)))
def save(self, *args, **kwargs):
created = self.pk is None
super(InstituteQuota, self).save(*args, **kwargs)
if created:
log.add(self.institute,
'Quota %s: Created' % self.machine_category)
for field in self._tracker.changed():
log.change(
self.institute, 'Quota %s: Changed %s to %s' %
(self.machine_category, field, getattr(self, field)))
from karaage.datastores import machine_category_save_institute
machine_category_save_institute(self.institute)
if created:
from karaage.datastores import add_accounts_to_institute
query = Account.objects.filter(person__groups=self.institute.group)
add_accounts_to_institute(query, self.institute)
def send_bounced_warning(person, leader_list):
"""Sends an email to each project leader for person
informing them that person's email has bounced"""
context = CONTEXT.copy()
context['person'] = person
for lp in leader_list:
leader = lp['leader']
context['project'] = lp['project']
context['receiver'] = leader
to_email = leader.email
subject = render_to_string(
'karaage/people/emails/bounced_email_subject.txt', context)
body = render_to_string('karaage/people/emails/bounced_email_body.txt',
context)
send_mail(subject.replace('\n', ''), body, settings.ACCOUNTS_EMAIL,
[to_email])
log.change(leader, 'Sent email about bounced emails from %s' % person)
def _next(self, request, application, roles, next_config):
""" Continue the state machine at given state. """
# we only support state changes for POST requests
if request.method == "POST":
key = None
# If next state is a transition, process it
while True:
# We do not expect to get a direct state transition here.
assert next_config['type'] in ['goto', 'transition']
while next_config['type'] == 'goto':
key = next_config['key']
next_config = self._config[key]
instance = load_instance(next_config)
if not isinstance(instance, Transition):
break
next_config = instance.get_next_config(request, application,
roles)
# lookup next state
assert key is not None
state_key = key
# enter that state
instance.enter_state(request, application)
application.state = state_key
application.save()
# log details
log.change(application.application_ptr,
"state: %s" % instance.name)
# redirect to this new state
url = get_url(request, application, roles)
return HttpResponseRedirect(url)
else:
return HttpResponseBadRequest("<h1>Bad Request</h1>")
def project_application_decline(request, token):
"""
Current model is to manually notify applicant.
Decline will archive user and project_application application.
"""
project_application = get_object_or_404(ProjectApplication,
secret_token=token)
if project_application.state in [
ProjectApplication.COMPLETE, ProjectApplication.ARCHIVED
]:
messages.error(request, "This application has already been approved")
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
if project_application.state == ProjectApplication.DECLINED:
messages.error(request, "This application was delined")
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
if project_application.state != ProjectApplication.WAITING_FOR_ADMIN:
messages.error(request, "Only submitted applications can be declined")
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
members = ProjectApplicationMember.objects.filter(
project_application=project_application)
supervisor = members.get(is_supervisor=True)
if request.method == 'POST':
project_application.state = ProjectApplication.DECLINED
project_application.save()
log.change(project_application, 'Declined by %s' % request.user)
messages.info(request,
"%s declined successfully." % project_application)
return HttpResponseRedirect(reverse('project_application_list'))
return render(
request,
'project_application/admin_confirm_decline.html',
{
'project_application': project_application,
'members': members,
'supervisor': supervisor
},
)
def approve(self, approved_by):
created_person, created_account = \
super(ProjectApplication, self).approve(approved_by)
assert self.applicant is not None
assert self.content_type.model == "person"
person = self.applicant
if self.project is None:
assert self.institute is not None
from karaage.projects.utils import get_new_pid
project = Project(
pid=self.pid or get_new_pid(self.institute),
name=self.name,
description=self.description,
institute=self.institute,
additional_req=self.additional_req,
start_date=datetime.datetime.today(),
end_date=datetime.datetime.today() +
datetime.timedelta(days=365),
)
project.save()
project.activate(approved_by)
self.project = project
self.save()
if self.make_leader:
self.project.leaders.add(person)
if self.needs_account:
if not person.has_account():
log.add(
self.application_ptr,
'Created account.'
)
Account.create(person, self.project)
created_account = True
else:
log.change(
self.application_ptr,
'Account already exists'
)
self.project.group.members.add(person)
return created_person, created_account
def save(self, *args, **kwargs):
created = self.pk is None
if not self.pk:
self.created_by = get_current_person()
self.expires = datetime.datetime.now() + datetime.timedelta(days=7)
parent = list(self._meta.parents.keys())[0]
subclasses = parent._meta.get_all_related_objects()
for klass in subclasses:
if isinstance(klass, RelatedObject) \
and klass.field.primary_key \
and klass.opts == self._meta:
self._class = klass.get_accessor_name()
break
super(Application, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(
self,
'Changed %s to %s' % (field, getattr(self, field)))
def _next(self, request, application, roles, next_config):
""" Continue the state machine at given state. """
# we only support state changes for POST requests
if request.method == "POST":
key = None
# If next state is a transition, process it
while True:
# We do not expect to get a direct state transition here.
assert next_config['type'] in ['goto', 'transition']
while next_config['type'] == 'goto':
key = next_config['key']
next_config = self._config[key]
instance = load_instance(next_config)
if not isinstance(instance, Transition):
break
next_config = instance.get_next_config(request, application, roles)
# lookup next state
assert key is not None
state_key = key
# enter that state
instance.enter_state(request, application)
application.state = state_key
application.save()
# log details
log.change(application.application_ptr, "state: %s" % instance.name)
# redirect to this new state
url = get_url(request, application, roles)
return HttpResponseRedirect(url)
else:
return HttpResponseBadRequest("<h1>Bad Request</h1>")
def save(self, *args, **kwargs):
created = self.pk is None
super(InstituteQuota, self).save(*args, **kwargs)
if created:
log.add(
self.institute,
'Quota %s: Created' % self.machine_category)
for field in self._tracker.changed():
log.change(
self.institute,
'Quota %s: Changed %s to %s' %
(self.machine_category, field, getattr(self, field)))
from karaage.datastores import machine_category_save_institute
machine_category_save_institute(self.institute)
if created:
from karaage.datastores import add_accounts_to_institute
query = Account.objects.filter(person__groups=self.institute.group)
add_accounts_to_institute(query, self.institute)
def save(self, *args, **kwargs):
created = self.pk is None
if not self.expires:
self.expires = datetime.datetime.now() + datetime.timedelta(days=7)
if not self.pk:
self.created_by = get_current_person()
# Find the accessor from Application to type(self) class
if hasattr(Application._meta, 'get_fields'):
# Django >= 1.8
fields = [
f for f in Application._meta.get_fields()
if isinstance(f, OneToOneRel) and f.field.primary_key
and f.auto_created
]
else:
# Django <= 1.8
fields = [
f for f in Application._meta.get_all_related_objects()
if isinstance(f, OneToOneRel) and f.field.primary_key
]
for rel in fields:
# Works with Django < 1.8 and => 1.8
related_model = getattr(rel, 'related_model', rel.model)
# if we find it, save the name
if related_model == type(self):
self._class = rel.get_accessor_name()
break
super(Application, self).save(*args, **kwargs)
if created:
log.add(self, 'Created')
for field in self._tracker.changed():
log.change(self,
'Changed %s to %s' % (field, getattr(self, field)))
def send_bounced_warning(person):
"""Sends an email to each project leader for person
informing them that person's email has bounced"""
context = CONTEXT.copy()
context['person'] = person
for project in person.project_set.filter(is_active=True):
context['project'] = project
for leader in project.leaders.filter(is_active=True):
context['receiver'] = leader
to_email = leader.email
subject = render_to_string(
'karaage/people/emails/bounced_email_subject.txt', context)
body = render_to_string(
'karaage/people/emails/bounced_email_body.txt', context)
send_mail(
subject.replace('\n', ''), body,
settings.ACCOUNTS_EMAIL, [to_email])
log.change(
leader,
'Sent email about bounced emails from %s' % person)
def _project_membership_changed(sender, instance, *args, **kwargs):
"""
This excecutes when a person is added to a project, and also when
one of these values in the ProjectMembership table changes:
- primary_contact
- project_leader
- project_supervisor
"""
try:
existing_data = ProjectMembership.objects.get(pk=instance.pk)
except ProjectMembership.DoesNotExist:
existing_data = None
project = instance.project
# Log a person being added to a project
if not existing_data:
message = '%s was added to the project.' % instance.person
log.change(project, message)
return
# Log changes to primary contact status
if instance.is_primary_contact != existing_data.is_primary_contact:
if instance.is_primary_contact:
message = '%s has become a primary contact' % instance.person
else:
message = '%s is no longer a primary contact' % instance.person
log.change(project, message)
# Log changes to project leader status
if instance.is_project_leader != existing_data.is_project_leader:
if instance.is_project_leader:
message = '%s has become a project leader' % instance.person
else:
message = '%s is no longer a project leader' % instance.person
log.change(project, message)
# Log changes to project supervisor status
if instance.is_project_supervisor != existing_data.is_project_supervisor:
if instance.is_project_supervisor:
message = '%s has become a supervisor' % instance.person
else:
message = '%s is no longer a supervisor' % instance.person
log.change(project, message)
def get_next_action(self, request, application, label, roles):
""" Process the get_next_action request at the current step. """
# if user is logged and and not applicant, steal the
# application
if 'is_applicant' in roles:
# if we got this far, then we either we are logged in as applicant,
# or we know the secret for this application.
new_person = None
reason = None
details = None
session_jwt = request.session.get('arc_jwt', None)
saml_id = None
if session_jwt is not None:
attributes = session_jwt['https://aaf.edu.au/attributes']
saml_id = attributes['edupersontargetedid']
if saml_id is not None:
query = Person.objects.filter(saml_id=saml_id)
if application.existing_person is not None:
query = query.exclude(pk=application.existing_person.pk)
if query.count() > 0:
new_person = Person.objects.get(saml_id=saml_id)
reason = "AAF id is already in use by existing person."
details = (
"It is not possible to continue this application "
+ "as is because the saml identity already exists "
+ "as a registered user.")
del query
if request.user.is_authenticated:
new_person = request.user
reason = "%s was logged in " \
"and accessed the secret URL." % new_person
details = (
"If you want to access this application "
+ "as %s " % application.applicant
+ "without %s stealing it, " % new_person
+ "you will have to ensure %s is " % new_person
+ "logged out first.")
if new_person is not None:
if application.applicant != new_person:
if 'steal' in request.POST:
old_applicant = application.applicant
application.new_applicant = None
application.existing_person = new_person
application.save()
log.change(
application.application_ptr,
"Stolen application from %s" % old_applicant)
messages.success(
request,
"Stolen application from %s" % old_applicant)
url = base.get_url(request, application, roles, label)
return HttpResponseRedirect(url)
else:
return render(
template_name='kgapplications'
'/project_aed_steal.html',
context={
'application': application,
'person': new_person,
'reason': reason,
'details': details,
},
request=request)
# if the user is the leader, show him the leader specific page.
if ('is_leader' in roles or 'is_delegate' in roles) \
and 'is_admin' not in roles \
and 'is_applicant' not in roles:
actions = ['reopen']
if 'reopen' in request.POST:
return 'reopen'
return render(
template_name='kgapplications/project_aed_for_leader.html',
context={'application': application,
'actions': actions, 'roles': roles, },
request=request)
# otherwise do the default behaviour for StateWithSteps
return super(StateApplicantEnteringDetails, self) \
.get_next_action(request, application, label, roles)
def _leaders_changed(sender, instance, action, reverse, model, pk_set,
**kwargs):
"""
Hook that executes whenever the group members are changed.
"""
# print("'%s','%s','%s','%s','%s'"
# %(instance, action, reverse, model, pk_set))
if action == "post_add":
if not reverse:
project = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person,
"Added person to project %s leaders" % project)
log.change(project,
"Added person %s to project leaders" % person)
else:
person = instance
for project in model.objects.filter(pk__in=pk_set):
log.change(person,
"Added person to project %s leaders" % project)
log.change(project,
"Added person %s to project leaders" % person)
elif action == "post_remove":
if not reverse:
project = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person,
"Removed person from project %s leaders" % project)
log.change(project,
"Removed person %s from project leaders" % person)
else:
person = instance
for project in model.objects.filter(pk__in=pk_set):
log.change(person,
"Removed person from project %s leaders" % project)
log.change(project,
"Removed person %s from project leaders" % person)
elif action == "pre_clear":
# This has to occur in pre_clear, not post_clear, as otherwise
# we won't see what project leaders need to be removed.
if not reverse:
project = instance
log.change(project, "Removed all project leaders")
for person in project.leaders.all():
log.change(project,
"Removed person %s from project leaders" % person)
else:
person = instance
log.change(person, "Removed person from all project leaders")
for project in person.leads.all():
log.change(project,
"Removed person %s from project leaders" % person)
def _members_changed(sender, instance, action, reverse, model, pk_set,
**kwargs):
"""
Hook that executes whenever the group members are changed.
"""
# print "'%s','%s','%s','%s','%s'" \
# %(instance, action, reverse, model, pk_set)
if action == "post_add":
if not reverse:
group = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person, "Added person to group %s" % group)
log.change(group, "Added person %s to group" % person)
_add_person_to_group(person, group)
else:
person = instance
for group in model.objects.filter(pk__in=pk_set):
log.change(person, "Added person to group %s" % group)
log.change(group, "Added person %s to group" % person)
_add_person_to_group(person, group)
elif action == "post_remove":
if not reverse:
group = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person, "Removed person from group %s" % group)
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
else:
person = instance
for group in model.objects.filter(pk__in=pk_set):
log.change(person, "Removed person from group %s" % group)
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
elif action == "pre_clear":
# This has to occur in pre_clear, not post_clear, as otherwise
# we won't see what groups need to be removed.
if not reverse:
group = instance
log.change(group, "Removed all people from group")
for person in group.members.all():
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
else:
person = instance
log.change(person, "Removed person from all groups")
for group in person.groups.all():
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
def _leaders_changed(
sender, instance, action, reverse, model, pk_set, **kwargs):
"""
Hook that executes whenever the group members are changed.
"""
# print("'%s','%s','%s','%s','%s'"
# %(instance, action, reverse, model, pk_set))
if action == "post_add":
if not reverse:
project = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(
person,
"Added person to project %s leaders" % project)
log.change(
project,
"Added person %s to project leaders" % person)
else:
person = instance
for project in model.objects.filter(pk__in=pk_set):
log.change(
person,
"Added person to project %s leaders" % project)
log.change(
project,
"Added person %s to project leaders" % person)
elif action == "post_remove":
if not reverse:
project = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(
person,
"Removed person from project %s leaders" % project)
log.change(
project,
"Removed person %s from project leaders" % person)
else:
person = instance
for project in model.objects.filter(pk__in=pk_set):
log.change(
person,
"Removed person from project %s leaders" % project)
log.change(
project,
"Removed person %s from project leaders" % person)
elif action == "pre_clear":
# This has to occur in pre_clear, not post_clear, as otherwise
# we won't see what project leaders need to be removed.
if not reverse:
project = instance
log.change(
project,
"Removed all project leaders")
for person in project.leaders.all():
log.change(
project,
"Removed person %s from project leaders" % person)
else:
person = instance
log.change(
person,
"Removed person from all project leaders")
for project in person.leads.all():
log.change(
project,
"Removed person %s from project leaders" % person)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Account, self).save(*args, **kwargs)
if created:
log.add(
self.person,
'Account %s: Created on %s' % (self, self.machine_category))
log.add(
self.machine_category,
'Account %s: Created on %s' % (self, self.machine_category))
for field in self._tracker.changed():
if field != "password":
log.change(
self.person, 'Account %s: Changed %s to %s' %
(self, field, getattr(self, field)))
log.change(
self.machine_category, 'Account %s: Changed %s to %s' %
(self, field, getattr(self, field)))
# check if machine_category changed
moved = False
if self._tracker.has_changed('machine_category_id'):
old_machine_category_pk = self._tracker.previous(
'machine_category_id')
if old_machine_category_pk is not None:
old_machine_category = MachineCategory.objects.get(
pk=old_machine_category_pk)
old_username = self._tracker.previous('username')
new_machine_category = self.machine_category
new_username = self.username
# set old values so we can delete old datastore
self.machine_category = old_machine_category
self.username = old_username
from karaage.datastores import machine_category_delete_account
machine_category_delete_account(self)
log.change(self.person, 'Account %s: Removed account' % self)
log.change(self.machine_category,
'Account %s: Removed account' % self)
# set new values again
self.machine_category = new_machine_category
self.username = new_username
log.change(self.person, 'Account %s: Added account' % self)
log.change(self.machine_category,
'Account %s: Added account' % self)
moved = True
# check if it was renamed
if self._tracker.has_changed('username'):
old_username = self._tracker.previous('username')
if old_username is not None:
new_username = self.username
if self.date_deleted is None and not moved:
from karaage.datastores \
import machine_category_set_account_username
machine_category_set_account_username(
self, old_username, new_username)
log.change(
self.person, 'Account %s: Changed username from %s to %s' %
(self, old_username, new_username))
log.change(
self.machine_category,
'Account %s: Changed username from %s to %s' %
(self, old_username, new_username))
# check if deleted status changed
if self._tracker.has_changed('date_deleted'):
if self.date_deleted is not None:
# account is deactivated
from karaage.datastores import machine_category_delete_account
machine_category_delete_account(self)
log.delete(self.person,
'Account %s: Deactivated account' % self)
log.delete(self.machine_category,
'Account %s: Deactivated account' % self)
# deleted
else:
# account is reactivated
log.add(self.person, 'Account %s: Activated' % self)
log.add(self.machine_category, 'Account %s: Activated' % self)
# makes sense to lock non-existant account
if self.date_deleted is not None:
self.login_enabled = False
# update the datastore
if self.date_deleted is None:
from karaage.datastores import machine_category_save_account
machine_category_save_account(self)
if self._password is not None:
from karaage.datastores \
import machine_category_set_account_password
machine_category_set_account_password(self, self._password)
log.change(self.person, 'Account %s: Changed Password' % self)
log.change(self.machine_category,
'Account %s: Changed Password' % self)
self._password = None
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Account, self).save(*args, **kwargs)
if created:
log.add(
self.person,
'Account %s: Created on %s' % (self, self.machine_category))
log.add(
self.machine_category,
'Account %s: Created on %s' % (self, self.machine_category))
for field in self._tracker.changed():
if field != "password":
log.change(
self.person,
'Account %s: Changed %s to %s'
% (self, field, getattr(self, field)))
log.change(
self.machine_category,
'Account %s: Changed %s to %s'
% (self, field, getattr(self, field)))
# check if machine_category changed
moved = False
if self._tracker.has_changed('machine_category_id'):
old_machine_category_pk = self._tracker.previous(
'machine_category_id')
if old_machine_category_pk is not None:
old_machine_category = MachineCategory.objects.get(
pk=old_machine_category_pk)
old_username = self._tracker.previous('username')
new_machine_category = self.machine_category
new_username = self.username
# set old values so we can delete old datastore
self.machine_category = old_machine_category
self.username = old_username
from karaage.datastores import machine_category_delete_account
machine_category_delete_account(self)
log.change(
self.person,
'Account %s: Removed account' % self)
log.change(
self.machine_category,
'Account %s: Removed account' % self)
# set new values again
self.machine_category = new_machine_category
self.username = new_username
log.change(
self.person,
'Account %s: Added account' % self)
log.change(
self.machine_category,
'Account %s: Added account' % self)
moved = True
# check if it was renamed
if self._tracker.has_changed('username'):
old_username = self._tracker.previous('username')
if old_username is not None:
new_username = self.username
if self.date_deleted is None and not moved:
from karaage.datastores \
import machine_category_set_account_username
machine_category_set_account_username(
self, old_username, new_username)
log.change(
self.person,
'Account %s: Changed username from %s to %s' %
(self, old_username, new_username))
log.change(
self.machine_category,
'Account %s: Changed username from %s to %s' %
(self, old_username, new_username))
# check if deleted status changed
if self._tracker.has_changed('date_deleted'):
if self.date_deleted is not None:
# account is deactivated
from karaage.datastores import machine_category_delete_account
machine_category_delete_account(self)
log.delete(
self.person,
'Account %s: Deactivated account' % self)
log.delete(
self.machine_category,
'Account %s: Deactivated account' % self)
# deleted
else:
# account is reactivated
log.add(
self.person,
'Account %s: Activated' % self)
log.add(
self.machine_category,
'Account %s: Activated' % self)
# makes sense to lock non-existant account
if self.date_deleted is not None:
self.login_enabled = False
# update the datastore
if self.date_deleted is None:
from karaage.datastores import machine_category_save_account
machine_category_save_account(self)
if self._password is not None:
from karaage.datastores \
import machine_category_set_account_password
machine_category_set_account_password(self, self._password)
log.change(
self.person,
'Account %s: Changed Password' % self)
log.change(
self.machine_category,
'Account %s: Changed Password' % self)
self._password = None
def _members_changed(
sender, instance, action, reverse, model, pk_set, **kwargs):
"""
Hook that executes whenever the group members are changed.
"""
# print "'%s','%s','%s','%s','%s'" \
# %(instance, action, reverse, model, pk_set)
if action == "post_add":
if not reverse:
group = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person, "Added person to group %s" % group)
log.change(group, "Added person %s to group" % person)
_add_person_to_group(person, group)
else:
person = instance
for group in model.objects.filter(pk__in=pk_set):
log.change(person, "Added person to group %s" % group)
log.change(group, "Added person %s to group" % person)
_add_person_to_group(person, group)
elif action == "post_remove":
if not reverse:
group = instance
for person in model.objects.filter(pk__in=pk_set):
log.change(person, "Removed person from group %s" % group)
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
else:
person = instance
for group in model.objects.filter(pk__in=pk_set):
log.change(person, "Removed person from group %s" % group)
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
elif action == "pre_clear":
# This has to occur in pre_clear, not post_clear, as otherwise
# we won't see what groups need to be removed.
if not reverse:
group = instance
log.change(group, "Removed all people from group")
for person in group.members.all():
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
else:
person = instance
log.change(person, "Removed person from all groups")
for group in person.groups.all():
log.change(group, "Removed person %s from group" % person)
_remove_person_from_group(person, group)
def view(self, request, application, label, roles, actions):
""" Process the view request at the current step. """
# if user is logged and and not applicant, steal the
# application
if 'is_applicant' in roles:
# if we got this far, then we either we are logged in as applicant,
# or we know the secret for this application.
new_person = None
reason = None
details = None
attrs, _ = saml.parse_attributes(request)
saml_id = attrs['persistent_id']
if saml_id is not None:
query = Person.objects.filter(saml_id=saml_id)
if application.content_type.model == "person":
query = query.exclude(pk=application.applicant.pk)
if query.count() > 0:
new_person = Person.objects.get(saml_id=saml_id)
reason = "SAML id is already in use by existing person."
details = (
"It is not possible to continue this application " +
"as is because the saml identity already exists " +
"as a registered user.")
del query
if request.user.is_authenticated():
new_person = request.user
reason = "%s was logged in " \
"and accessed the secret URL." % new_person
details = (
"If you want to access this application " +
"as %s " % application.applicant +
"without %s stealing it, " % new_person +
"you will have to ensure %s is " % new_person +
"logged out first.")
if new_person is not None:
if application.applicant != new_person:
if 'steal' in request.POST:
old_applicant = application.applicant
application.applicant = new_person
application.save()
log.change(
application.application_ptr,
"Stolen application from %s" % old_applicant)
messages.success(
request,
"Stolen application from %s" % old_applicant)
url = base.get_url(request, application, roles, label)
return HttpResponseRedirect(url)
else:
return render(
template_name='kgapplications'
'/project_aed_steal.html',
context={
'application': application,
'person': new_person,
'reason': reason,
'details': details,
},
request=request)
# if the user is the leader, show him the leader specific page.
if ('is_leader' in roles or 'is_delegate' in roles) \
and 'is_admin' not in roles \
and 'is_applicant' not in roles:
actions = ['reopen']
if 'reopen' in request.POST:
return 'reopen'
return render(
template_name='kgapplications/project_aed_for_leader.html',
context={'application': application,
'actions': actions, 'roles': roles, },
request=request)
# otherwise do the default behaviour for StateWithSteps
return super(StateApplicantEnteringDetails, self) \
.view(request, application, label, roles, actions)
def save(self, *args, **kwargs):
created = self.pk is None
# save the object
super(Account, self).save(*args, **kwargs)
if created:
log.add(
self.person,
'Account %s: Created' % self)
for field in self._tracker.changed():
if field != "password":
log.change(
self.person,
'Account %s: Changed %s to %s'
% (self, field, getattr(self, field)))
# check if it was renamed
if self._tracker.has_changed('username'):
old_username = self._tracker.previous('username')
if old_username is not None:
new_username = self.username
if self.date_deleted is None:
from karaage.datastores import set_account_username
set_account_username(self, old_username, new_username)
log.change(
self.person,
'Account %s: Changed username from %s to %s' %
(self, old_username, new_username))
# check if deleted status changed
if self._tracker.has_changed('date_deleted'):
if self.date_deleted is not None:
# account is deactivated
from karaage.datastores import delete_account
delete_account(self)
log.delete(
self.person,
'Account %s: Deactivated account' % self)
# deleted
else:
# account is reactivated
log.add(
self.person,
'Account %s: Activated' % self)
# makes sense to lock non-existant account
if self.date_deleted is not None:
self.login_enabled = False
# update the datastore
if self.date_deleted is None:
from karaage.datastores import save_account
save_account(self)
if self._password is not None:
from karaage.datastores import set_account_password
set_account_password(self, self._password)
log.change(
self.person,
'Account %s: Changed Password' % self)
self._password = None
def view(self, request, application, label, roles, actions):
""" Process the view request at the current step. """
# if user is logged and and not applicant, steal the
# application
if 'is_applicant' in roles:
# if we got this far, then we either we are logged in as applicant,
# or we know the secret for this application.
new_person = None
attrs, _ = saml.parse_attributes(request)
saml_id = attrs['persistent_id']
if saml_id is not None:
query = Person.objects.filter(saml_id=saml_id)
if application.content_type.model == "person":
query = query.exclude(pk=application.applicant.pk)
if query.count() > 0:
new_person = Person.objects.get(saml_id=saml_id)
reason = "SAML id is already in use by existing person."
details = (
"It is not possible to continue this application " +
"as is because the saml identity already exists " +
"as a registered user.")
del query
if request.user.is_authenticated():
new_person = request.user
reason = "%s was logged in " \
"and accessed the secret URL." % new_person
details = ("If you want to access this application " +
"as %s " % application.applicant +
"without %s stealing it, " % new_person +
"you will have to ensure %s is " % new_person +
"logged out first.")
if new_person is not None:
if application.applicant != new_person:
if 'steal' in request.POST:
old_applicant = application.applicant
application.applicant = new_person
application.save()
log.change(
application.application_ptr,
"Stolen application from %s" % old_applicant)
messages.success(
request,
"Stolen application from %s" % old_applicant)
url = base.get_url(request, application, roles, label)
return HttpResponseRedirect(url)
else:
return render_to_response(
'kgapplications/project_aed_steal.html', {
'application': application,
'person': new_person,
'reason': reason,
'details': details,
},
context_instance=RequestContext(request))
# if the user is the leader, show him the leader specific page.
if ('is_leader' in roles or 'is_delegate' in roles) \
and 'is_admin' not in roles \
and 'is_applicant' not in roles:
actions = ['reopen']
if 'reopen' in request.POST:
return 'reopen'
return render_to_response(
'kgapplications/project_aed_for_leader.html', {
'application': application,
'actions': actions,
'roles': roles,
},
context_instance=RequestContext(request))
# otherwise do the default behaviour for StateWithSteps
return super(StateApplicantEnteringDetails, self) \
.view(request, application, label, roles, actions)
