def setUp(self):
"""
"""
create_workflow(self)
# roles
self.anonymous = permissions.utils.register_role('Anonymous')
self.publisher = permissions.utils.register_role('Publisher')
self.anonymous_user = User.objects.create(username='******')
permissions.utils.add_role(self.anonymous_user, self.anonymous)
self.test_user = User.objects.create(username='******',
first_name='Test',
last_name='User')
permissions.utils.add_role(self.test_user, self.publisher)
self.flat_page = FlatPage.objects.create(url='/page-1',
title='Page 1',
initializer=self.test_user)
# permissions
self.edit = permissions.utils.register_permission('Edit', 'edit')
self.view = permissions.utils.register_permission('View', 'view')
# state, transition
self.rejected = State.objects.create(name='Rejected', workflow=self.w)
self.reject = Transition.objects.create(name='Reject',
workflow=self.w,
destination=self.rejected,
permission=self.edit)
self.private.transitions.add(self.reject)
# permissions for the workflow
WorkflowPermissionRelation.objects.create(workflow=self.w,
permission=self.edit)
WorkflowPermissionRelation.objects.create(workflow=self.w,
permission=self.view)
# permissions for states
StatePermissionRelation.objects.create(state=self.public,
permission=self.view,
role=self.publisher)
StatePermissionRelation.objects.create(state=self.private,
permission=self.edit,
role=self.publisher)
StatePermissionRelation.objects.create(state=self.private,
permission=self.view,
role=self.publisher)
StatePermissionRelation.objects.create(state=self.rejected,
permission=self.view,
role=self.publisher)
# permissions on transition
self.make_public.permission = self.edit
self.make_public.save()
self.make_private.permission = self.edit
self.make_private.save()
set_workflow(self.flat_page, self.w)
def set_workflow(request):
workflow = Workflow.objects.get(name="Standard")
name=request.REQUEST.get('name')
from workflows.utils import set_workflow
project=Project.objects.get(name=name)
set_workflow(project, workflow)
state=get_state(project)
ts=state.get_allowed_transitions
def setUp(self):
"""
"""
create_workflow(self)
self.user = User.objects.create(username='******',
first_name='Test', last_name='User')
self.flat_page = FlatPage.objects.create(url='/page-1', title='Page 1',
initializer=self.user)
set_workflow(self.flat_page, self.w)
def setup_order_workflow(sender, instance, created, **kwargs):
if created:
if not instance.workflow:
# Set default workflow
log.debug("Setting default workflow for %s" % instance)
w = instance.gas.config.default_workflow_gassupplier_order
set_workflow(instance, w)
instance.open_if_needed()
def test_get_allowed_transitions_without_permissions(self):
"""
If no permissions are set, all available transitions should be returned.
"""
set_workflow(self.gas_1, self.workflow)
# retrieve allowed transitions via the utility function
allowed_transitions = get_allowed_transitions(self.gas_1, self.user)
self.assertEqual(set(allowed_transitions), set((self.close, self.ignore, self.archive)))
# retrieve allowed transitions via `State` model's method
allowed_transitions = self.open.get_allowed_transitions(self.gas_1, self.user)
self.assertEqual(set(allowed_transitions), set((self.close, self.ignore, self.archive)))
def setup_order_workflow(sender, instance, created, **kwargs):
if created:
if not instance.workflow:
# Set default workflow
log.debug("Setting default workflow for %s" % instance)
w = instance.gas.config.default_workflow_gassupplier_order
set_workflow(instance, w)
instance.open_if_needed()
def setUp(self):
"""
"""
create_workflow(self)
self.user = User.objects.create(username='******',
first_name='Test',
last_name='User')
self.flat_page = FlatPage.objects.create(url='/page-1',
title='Page 1',
initializer=self.user)
set_workflow(self.flat_page, self.w)
def setUp(self):
"""
"""
create_workflow(self)
# roles
self.anonymous = permissions.utils.register_role('Anonymous')
self.publisher = permissions.utils.register_role('Publisher')
self.anonymous_user = User.objects.create(username='******')
permissions.utils.add_role(self.anonymous_user, self.anonymous)
self.test_user = User.objects.create(username='******',
first_name='Test', last_name='User')
permissions.utils.add_role(self.test_user, self.publisher)
self.flat_page = FlatPage.objects.create(url='/page-1', title='Page 1',
initializer=self.test_user)
# permissions
self.edit = permissions.utils.register_permission('Edit', 'edit')
self.view = permissions.utils.register_permission('View', 'view')
# state, transition
self.rejected = State.objects.create(name='Rejected', workflow=self.w)
self.reject = Transition.objects.create(name='Reject',
workflow=self.w, destination=self.rejected,
permission=self.edit)
self.private.transitions.add(self.reject)
# permissions for the workflow
WorkflowPermissionRelation.objects.create(workflow=self.w,
permission=self.edit)
WorkflowPermissionRelation.objects.create(workflow=self.w,
permission=self.view)
# permissions for states
StatePermissionRelation.objects.create(state=self.public,
permission=self.view, role=self.publisher)
StatePermissionRelation.objects.create(state=self.private,
permission=self.edit, role=self.publisher)
StatePermissionRelation.objects.create(state=self.private,
permission=self.view, role=self.publisher)
StatePermissionRelation.objects.create(state=self.rejected,
permission=self.view, role=self.publisher)
# permissions on transition
self.make_public.permission = self.edit
self.make_public.save()
self.make_private.permission = self.edit
self.make_private.save()
set_workflow(self.flat_page, self.w)
def test_get_allowed_transitions_without_permissions(self):
"""
If no permissions are set, all available transitions should be returned.
"""
set_workflow(self.gas_1, self.workflow)
# retrieve allowed transitions via the utility function
allowed_transitions = get_allowed_transitions(self.gas_1, self.user)
self.assertEqual(set(allowed_transitions),
set((self.close, self.ignore, self.archive)))
# retrieve allowed transitions via `State` model's method
allowed_transitions = self.open.get_allowed_transitions(
self.gas_1, self.user)
self.assertEqual(set(allowed_transitions),
set((self.close, self.ignore, self.archive)))
def perm(request):
workflow = Workflow.objects.get(name="Standard")
private = State.objects.get(name="Private", workflow= workflow)
public = State.objects.get(name="Public", workflow= workflow)
# Add a role
from permissions.utils import register_role
owner = Role.objects.get(name='Owner')
# Create a user
from django.contrib.auth.models import User
user = User.objects.get(username="******")
# Assign user to role
owner.add_principal(user)
# Create example content type
page_1 = Project.objects.get(name="abc")
# Register permissions
from permissions.utils import register_permission
view = register_permission("View", "view")
edit = register_permission("Edit", "edit")
# Add all permissions which are managed by the workflow
from workflows.models import WorkflowPermissionRelation
WorkflowPermissionRelation.objects.create(workflow=workflow, permission=view)
WorkflowPermissionRelation.objects.create(workflow=workflow, permission=edit)
# Add permissions for the single states
from workflows.models import StatePermissionRelation
StatePermissionRelation.objects.create(state=public, permission=view, role=owner)
StatePermissionRelation.objects.create(state=private, permission=view, role=owner)
StatePermissionRelation.objects.create(state=private, permission=edit, role=owner)
# Assign the workflow to the content object
from workflows.utils import set_workflow
set_workflow(page_1, workflow)
# Now self.page_1 has the intial workflow state.
from permissions.utils import has_permission
print has_permission(page_1, user, "edit")
# Now we change the workflow state
set_state(page_1, public)
print has_permission(page_1, user, "edit")
def _add_to_workflow(self):
'''
Adds the EthicsApplication to the workflow that is defined in Settings.APPLICATION_WORKFLOW
Will raise an ImproperlConfigured exception if this setting is not set, or the workflow defined
doesn't exist.
'''
workflow_code = getattr(settings, 'APPLICATION_WORKFLOW', None)
if workflow_code != None:
try:
approval_workflow = Workflow.objects.get(name=workflow_code)
set_workflow(self, approval_workflow)
except ObjectDoesNotExist:
raise ImproperlyConfigured('The workflow you specify in APPLICATION_WORKFLOW must actually be configured in the db')
else:
raise ImproperlyConfigured('You must set APPLICATION_WORKFLOW in the settings file')
def request_for_sharing(request):
"""
send a request for sharing to resource owner
"""
resource = Resource.objects.get(id=request.GET.get('id'))
relatedResources = request.GET.getlist('relatedResources', [])
resource_request, created = ResourceRequest.objects.get_or_create(resource=resource, requestor=request.user)
resource_request.message = request.GET.get('message', None)
resource_request.save()
set_workflow(resource_request, ResourceRequestWorkflow)
set_state(resource_request, request_pending)
# alert owner by email
try:
alert_user_by_email(
mail_from='VPH-Share Webmaster <*****@*****.**>',
mail_to='%s %s <%s>' % (resource.owner.first_name, resource.owner.last_name, resource.owner.email),
subject='[VPH-Share] You have receive a request for sharing',
mail_template='incoming_request_for_sharing',
dictionary={
'message': request.GET.get('message', None),
'resource': resource,
'requestor': request.user,
'BASE_URL': settings.BASE_URL
}
)
# alert requestor by email
alert_user_by_email(
mail_from='VPH-Share Webmaster <*****@*****.**>',
mail_to='%s %s <%s>' % (request.user.first_name, request.user.last_name, request.user.email),
mail_template='request_for_sharing_sent',
subject='[VPH-Share] Your request for sharing has been delivered to resource owner',
dictionary={
'requestor': request.user
}
)
except Exception, e:
pass
def _add_to_workflow(self):
'''
Adds the EthicsApplication to the workflow that is defined in Settings.APPLICATION_WORKFLOW
Will raise an ImproperlConfigured exception if this setting is not set, or the workflow defined
doesn't exist.
'''
workflow_code = getattr(settings, 'APPLICATION_WORKFLOW', None)
if workflow_code != None:
try:
approval_workflow = Workflow.objects.get(name=workflow_code)
set_workflow(self, approval_workflow)
except ObjectDoesNotExist:
raise ImproperlyConfigured(
'The workflow you specify in APPLICATION_WORKFLOW must actually be configured in the db'
)
else:
raise ImproperlyConfigured(
'You must set APPLICATION_WORKFLOW in the settings file')
def test_get_editable_instances(self):
"""
"""
second_page = FlatPage.objects.create(url='/page-2',
title='Page 2',
initializer=self.test_user)
third_page = FlatPage.objects.create(url='/page-3',
title='Page 3',
initializer=self.test_user)
fourth_page = FlatPage.objects.create(url='/page-4',
title='Page 4',
initializer=self.test_user)
fifth_page = FlatPage.objects.create(url='/page-5',
title='Page 5',
initializer=self.test_user)
set_workflow(self.flat_page, self.w)
set_workflow(second_page, self.w)
set_workflow(third_page, self.w)
result = FlatPage.pending.editable_by_roles([self.publisher])
self.assertListEqual(list(result),
[self.flat_page, second_page, third_page])
result = FlatPage.pending.editable_by_roles([self.anonymous])
self.assertListEqual(list(result), [])
self.flat_page.change_state(self.make_public, self.test_user)
second_page.change_state(self.reject, self.test_user)
result = FlatPage.pending.editable_by_roles([self.publisher])
self.assertListEqual(list(result), [third_page])
def test_get_editable_instances(self):
"""
"""
second_page = FlatPage.objects.create(url='/page-2', title='Page 2',
initializer=self.test_user)
third_page = FlatPage.objects.create(url='/page-3', title='Page 3',
initializer=self.test_user)
fourth_page = FlatPage.objects.create(url='/page-4', title='Page 4',
initializer=self.test_user)
fifth_page = FlatPage.objects.create(url='/page-5', title='Page 5',
initializer=self.test_user)
set_workflow(self.flat_page, self.w)
set_workflow(second_page, self.w)
set_workflow(third_page, self.w)
result = FlatPage.pending.editable_by_roles([self.publisher])
self.assertListEqual(list(result), [self.flat_page, second_page,
third_page])
result = FlatPage.pending.editable_by_roles([self.anonymous])
self.assertListEqual(list(result), [])
self.flat_page.change_state(self.make_public, self.test_user)
second_page.change_state(self.reject, self.test_user)
result = FlatPage.pending.editable_by_roles([self.publisher])
self.assertListEqual(list(result), [third_page])
def create(request):
'''
Create a new token, for which the logged in user will be the owner
'''
if request.method == "POST":
form = TokenForm(request.POST)
if form.is_valid():
token = form.save()
#get the user and supervisor
user = request.user
supervisor = user.supervisee.all()[0].supervisor
#get the researcher and supervisor roles
token_generator_role = Role.objects.get(name='Token_Generator')
supervisor_role = Role.objects.get(name='Supervisor')
#get the approval workflow
approval_workflow = Workflow.objects.get(name='Token_Approval')
#add the user and their supervisor as local roles for this token
add_local_role(token, user, token_generator_role)
add_local_role(token, supervisor, supervisor_role)
set_workflow(token, approval_workflow)
# redirect to home
return HttpResponseRedirect(reverse('home_view'))
else:
form = TokenForm()
return render_to_response("create_token.html", {"form": form,'edit':False,}, context_instance=RequestContext(request) )
def create_institution(request):
"""
submit a request to create an institution
"""
if request.method == 'POST':
if request.user.id not in request.POST.getlist('managers'):
request.POST.appendlist('managers', unicode(request.user.id))
# filter post field "name"
request.POST['name'] = ''.join( c for c in request.POST['name'] if c.isalnum() )
form = InstitutionForm(request.POST, request.FILES)
if form.is_valid():
group = form.save(commit=False)
group.save()
set_workflow(group, GroupRequestWorkflow)
set_state(group, group_pending)
return redirect('/groups')
else:
return render_to_response(
'scs_groups/createinstitution.html',
{'form': form},
RequestContext(request)
)
else:
form = InstitutionForm(initial={'managers': [request.user]})
return render_to_response(
'scs_groups/createinstitution.html',
{'form': form},
RequestContext(request)
)
def subscribe(request, idGroup=None, idStudy=None, iduser=None):
"""
create a subscription_pending subscription to an institution
"""
if request.method == 'POST':
if idStudy is not None:
group, gtype = get_group_by_id(idStudy)
else:
group, gtype = get_group_by_id(idGroup)
if iduser is None:
subscription = SubscriptionRequest(user=request.user, group=group)
subscription.save()
set_workflow(subscription, SubscriptionRequestWorkflow)
set_state(subscription, subscription_pending)
elif request.user in group.managers.all():
user = User.objects.get(pk=iduser)
subscription = SubscriptionRequest.objects.get(user=user, group=group)
if request.POST['operation'] == 'accept':
if do_transition(subscription, subscription_accept_subscription, request.user):
group.user_set.add(user)
subscription.delete()
else:
do_transition(subscription, subscription_refuse_subscription, request.user)
subscription.delete()
if gtype == 1:
return redirect('/groups/%s/%s/' % (idGroup, idStudy))
else:
return redirect('/groups/%s/' % idGroup)
return redirect('/groups')
def test_by_state(self):
set_workflow(self.first_page, self.w)
set_workflow(self.second_page, self.w)
set_workflow(self.third_page, self.w)
result = FlatPage.objects.by_state('Private')
self.assertListEqual(
list(result), [self.first_page, self.second_page, self.third_page])
self.assertIsInstance(result, QuerySet)
self.first_page.change_state(self.make_public, self.user)
result = FlatPage.objects.by_state('Public')
self.assertListEqual(list(result), [self.first_page])
def test_by_state(self):
set_workflow(self.first_page, self.w)
set_workflow(self.second_page, self.w)
set_workflow(self.third_page, self.w)
result = FlatPage.objects.by_state('Private')
self.assertListEqual(list(result), [self.first_page, self.second_page,
self.third_page])
self.assertIsInstance(result, QuerySet)
self.first_page.change_state(self.make_public, self.user)
result = FlatPage.objects.by_state('Public')
self.assertListEqual(list(result), [self.first_page])
def test_ended_manager(self):
set_workflow(self.first_page, self.w)
set_workflow(self.second_page, self.w)
set_workflow(self.third_page, self.w)
result = FlatPage.ended.all()
self.assertListEqual(list(result), [])
self.first_page.change_state(self.make_public, self.user)
self.second_page.change_state(self.reject, self.user)
result = FlatPage.ended.all()
self.assertListEqual(list(result), [self.second_page])
result = result.by_state('Rejected')
self.assertListEqual(list(result), [self.second_page])
def test_ended_manager(self):
set_workflow(self.first_page, self.w)
set_workflow(self.second_page, self.w)
set_workflow(self.third_page, self.w)
result = FlatPage.ended.all()
self.assertListEqual(list(result), [])
self.first_page.change_state(self.make_public, self.user)
self.second_page.change_state(self.reject, self.user)
result = FlatPage.ended.all()
self.assertListEqual(list(result), [self.second_page])
result = result.by_state('Rejected')
self.assertListEqual(list(result), [self.second_page])
mail_template='request_for_sharing_sent',
subject='[VPH-Share] Your request for sharing has been delivered to resource owner',
dictionary={
'requestor': request.user
}
)
except Exception, e:
pass
for related in relatedResources:
resource = Resource.objects.get(global_id=related)
resource_request, created = ResourceRequest.objects.get_or_create(resource=resource, requestor=request.user)
resource_request.message = request.GET.get('message', None)
resource_request.save()
set_workflow(resource_request, ResourceRequestWorkflow)
set_state(resource_request, request_pending)
# alert owner by email
try:
alert_user_by_email(
mail_from='VPH-Share Webmaster <*****@*****.**>',
mail_to='%s %s <%s>' % (resource.owner.first_name, resource.owner.last_name, resource.owner.email),
subject='[VPH-Share] You have receive a request for sharing',
mail_template='incoming_request_for_sharing',
dictionary={
'message': request.GET.get('message', None),
'resource': resource,
'requestor': request.user,
'BASE_URL': settings.BASE_URL
}
