def update(request, proj_id, iframe=False):
'''Update information about a project'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_edit_project")
def redirect(instance):
if iframe:
return reverse("project_list")
else:
return reverse("project_detail", args=[instance.id])
return generic_crud(
request, proj_id,
model=Project,
form_class=ProjectCreateForm,
template=TEMPLATE_PATH+"/create_update.html",
redirect=redirect,
template_object_name="project",
extra_context={
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % project.name, reverse("project_detail", args=[project.id])),
("Update Info", request.path),
),
},
success_msg = lambda instance: "Successfully updated project %s." % instance.name,
)
def update(request, proj_id, iframe=False):
'''Update information about a project'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_edit_project")
def redirect(instance):
if iframe:
return reverse("project_list")
else:
return reverse("project_detail", args=[instance.id])
return generic_crud(
request,
proj_id,
model=Project,
form_class=ProjectCreateForm,
template=TEMPLATE_PATH + "/create_update.html",
redirect=redirect,
template_object_name="project",
extra_context={
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % project.name,
reverse("project_detail", args=[project.id])),
("Update Info", request.path),
),
},
success_msg=lambda instance: "Successfully updated project %s." %
instance.name,
)
def update(request, role_id):
"""Update the permissions in the role"""
role = get_object_or_404(ProjectRole, pk=role_id)
# require permission to proceed
must_have_permission(request.user, role.project, "can_edit_roles")
permittee = Permittee.objects.get_as_permittee(request.user)
initial_set = list(role.obj_permissions.values_list("pk", flat=True))
# Get the permissions that the user can delegate to others as well
# as the ones that are already in the role. Obtain DISTINCT values.
obj_permissions = ObjectPermission.objects.filter_from_instance(
role.project).filter(
Q(permissionownership__permittee=permittee,
permissionownership__can_delegate=True)
| Q(id__in=initial_set)).distinct()
project_url = reverse("project_detail", args=[role.project.id])
# Use to update the permissions in the ProjectRole object so
# users with that role are affected from the time this is updated
def post_save(instance, created):
from expedient.clearinghouse.roles.models import ObjectPermission
new_obj_permissions_pks = [
p.pk for p in instance.obj_permissions.all()
]
for permission in obj_permissions:
# Add and delete permissions accordingly...
try:
instance.remove_permission(permission)
except:
pass
if permission.pk in new_obj_permissions_pks:
instance.add_permission(permission)
return generic_crud(
request,
obj_id=role_id,
model=ProjectRole,
template=TEMPLATE_PATH + "/update.html",
redirect=lambda instance: project_url,
template_object_name="role",
form_class=ProjectRoleForm,
extra_form_params={
"obj_permissions": obj_permissions,
},
extra_context={
"project":
role.project,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % role.project.name, project_url),
("Update Role %s" % role.name, request.path),
)
},
post_save=post_save,
)
def aggregate_edit(request,
agg_id,
agg_model,
redirect=lambda inst: reverse("home")):
"""
Update a GENI Aggregate.
@param request: The request object
@param agg_id: the aggregate id
@param agg_model: the GENI Aggregate subclass.
@keyword redirect: Function that takes the created instance and returns
a url to redirect to.
"""
def success_msg(instance):
return "Successfully updated aggregate %s." % instance.name
def post_save(instance, created):
instance.update_resources()
return generic_crud(request,
obj_id=agg_id,
model=agg_model,
template=TEMPLATE_PATH + "/aggregate_crud.html",
template_object_name="aggregate",
redirect=redirect,
post_save=post_save,
form_class=geni_aggregate_form_factory(agg_model),
success_msg=success_msg)
def create(request, proj_id):
"""Create a new role for a project."""
project = get_object_or_404(Project, pk=proj_id)
# require permission to proceed
must_have_permission(request.user, project, "can_create_roles")
obj_permissions = ObjectPermission.objects.filter_from_instance(project)
project_url = reverse("project_detail", args=[project.id])
def pre_save(instance, created):
instance.project = project
return generic_crud(request,
obj_id=None,
model=ProjectRole,
template=TEMPLATE_PATH + "/create.html",
redirect=lambda instance: project_url,
form_class=ProjectRoleForm,
pre_save=pre_save,
extra_form_params={
"obj_permissions": obj_permissions,
},
extra_context={
"project":
project,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % project.name, project_url),
("Create Role", request.path),
)
})
def aggregate_edit(request, agg_id, agg_model,
redirect=lambda inst: reverse("home")):
"""
Update a GENI Aggregate.
@param request: The request object
@param agg_id: the aggregate id
@param agg_model: the GENI Aggregate subclass.
@keyword redirect: Function that takes the created instance and returns
a url to redirect to.
"""
def success_msg(instance):
return "Successfully updated aggregate %s." % instance.name
def post_save(instance, created):
instance.update_resources()
return generic_crud(
request, obj_id=agg_id, model=agg_model,
template="aggregate_crud.html",
template_object_name="aggregate",
redirect=redirect,
post_save=post_save,
form_class=geni_aggregate_form_factory(agg_model),
success_msg=success_msg)
def create(request):
'''
Create a new message
'''
if request.user.is_superuser:
message_class = MessageForm
else:
message_class = MessageFormNoIM
# Non-IM user should not be able to impersonate anyone...
filtered_sender = User.objects.filter(username=request.user.username)
message_class.__dict__["base_fields"]["sender"].__dict__["_queryset"] = filtered_sender
# Exclude the user itself from the recipients' list
filtered_users = User.objects.exclude(username=request.user.username)
# Order users by name
message_class.__dict__["base_fields"]["users"].__dict__["_queryset"] = filtered_users.order_by("username")
filtered_senders = message_class.__dict__["base_fields"]["sender"].__dict__["_queryset"]
message_class.__dict__["base_fields"]["sender"].__dict__["_queryset"] = filtered_senders.order_by("username")
# Original
# return create_message(
# request,
# form_class=message_class,
# template_name="expedient/common/messaging/create.html",
# post_save_redirect=reverse("messaging_created"),
# )
return generic_crud(
request, None, None,"expedient/common/messaging/create.html",
redirect=lambda instance:reverse("messaging_center"),
form_class=message_class,
success_msg = lambda instance: "Successfully sent message.",
)
def create(request, proj_id):
'''Create a slice'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_create_slices")
#<UT>
user_profile = UserProfile.get_or_create_profile(request.user)
user_urn = user_profile.urn
user_cert = user_profile.certificate
def pre_save(instance, created):
instance.project = project
instance.owner = request.user
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
#<UT>
instance.urn = 'n/a'
#import pdb; pdb.set_trace()
if settings.ENABLE_CBAS:
slice_urn = create_slice(owner_urn=user_urn,
owner_certificate=user_cert,
slice_name=instance.name,
slice_desc=instance.description,
slice_project_urn=str(project.urn))
if slice_urn:
instance.urn = slice_urn
instance.save()
instance.reserved = False
#use to give the can_delete_slices over the slice to the creator and the owners of the project
def post_save(instance, created):
give_permission_to("can_delete_slices",
instance,
instance.owner,
giver=None,
can_delegate=False)
# for projectOwner in instance.project._get_owners():
# give_permission_to("can_delete_slices", instance, projectOwner, giver=None, can_delegate=False)
return generic_crud(
request,
None,
Slice,
TEMPLATE_PATH + "/create_update.html",
redirect=lambda instance: reverse("slice_detail", args=[instance.id]),
form_class=SliceCrudForm,
extra_context={
"project": project,
"title": "Create slice",
"cancel_url": reverse("project_detail", args=[proj_id]),
},
pre_save=pre_save,
post_save=post_save,
success_msg=lambda instance: "Successfully created slice %s." %
instance.name,
)
def create(request):
"""
Create a new project
"""
user_profile = UserProfile.get_or_create_profile(request.user)
cert = user_profile.certificate
creds = user_profile.credentials
user_urn = user_profile.urn
def post_save(instance, created):
# Create default roles in the project
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
#<UT>
instance.urn = "n/a"
#import pdb; pdb.set_trace()
if settings.ENABLE_CBAS:
project_urn = create_project(certificate=cert, credentials=creds,
project_name=instance.name, project_desc=instance.description,
user_urn=user_urn)
if project_urn:
instance.urn = project_urn
create_project_roles(instance, request.user)
instance.save()
#if settings.LDAP_STORE_PROJECTS:
# instance.sync_netgroup_ldap()
def redirect(instance):
return reverse("project_detail", args=[instance.id])
try:
return generic_crud(
request, None,
model=Project,
form_class=ProjectCreateForm,
template=TEMPLATE_PATH+"/create_update.html",
post_save=post_save,
redirect=redirect,
template_object_name="project",
extra_context={
"breadcrumbs": (
("Home", reverse("home")),
("Create Project", request.path),
),
},
success_msg = lambda instance: "Successfully created project %s." % instance.name,
)
except Exception as e:
if isinstance(e,ldap.LDAPError):
DatedMessage.objects.post_message_to_user(
"Project has been created but only locally since LDAP is not reachable. You will not be able to add users to the project until connection is restored.",
request.user, msg_type=DatedMessage.TYPE_ERROR)
else:
DatedMessage.objects.post_message_to_user(
"Project may have been created, but some problem ocurred: %s" % str(e),
request.user, msg_type=DatedMessage.TYPE_ERROR)
return HttpResponseRedirect(reverse("home"))
def update(request, role_id):
"""Update the permissions in the role"""
role = get_object_or_404(ProjectRole, pk=role_id)
# require permission to proceed
must_have_permission(request.user, role.project, "can_edit_roles")
permittee = Permittee.objects.get_as_permittee(request.user)
initial_set = list(role.obj_permissions.values_list("pk", flat=True))
# Get the permissions that the user can delegate to others as well
# as the ones that are already in the role. Obtain DISTINCT values.
obj_permissions = ObjectPermission.objects.filter_from_instance(
role.project).filter(
Q(permissionownership__permittee=permittee,
permissionownership__can_delegate=True) |
Q(id__in=initial_set)
).distinct()
project_url = reverse("project_detail", args=[role.project.id])
# Use to update the permissions in the ProjectRole object so
# users with that role are affected from the time this is updated
def post_save(instance, created):
from expedient.clearinghouse.roles.models import ObjectPermission
new_obj_permissions_pks = [ p.pk for p in instance.obj_permissions.all() ]
for permission in obj_permissions:
# Add and delete permissions accordingly...
try:
instance.remove_permission(permission)
except:
pass
if permission.pk in new_obj_permissions_pks:
instance.add_permission(permission)
return generic_crud(
request,
obj_id=role_id,
model=ProjectRole,
template=TEMPLATE_PATH+"/update.html",
redirect=lambda instance: project_url,
template_object_name="role",
form_class=ProjectRoleForm,
extra_form_params={
"obj_permissions": obj_permissions,
},
extra_context={
"project": role.project,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % role.project.name, project_url),
("Update Role %s" % role.name, request.path),
)
},
post_save = post_save,
)
def create(request):
def pre_save(instance, created):
instance.owner = request.user
return generic_crud(
request,
obj_id=None,
model=DummyAggregate,
form_class=DummyAggForm,
pre_save=pre_save,
redirect=lambda (instance): "/",
template="aggregate_tests/form.html",
)
def aggregate_crud(request, agg_id=None):
"""Show a page for the user to add/edit an SSH aggregate in Expedient."""
return generic_crud(
request,
obj_id=agg_id,
model=SSHAggregate,
template_object_name="aggregate",
template="sshaggregate/aggregate_crud.html",
redirect=lambda inst: reverse(
aggregate_add_servers, args=[inst.id]),
success_msg=lambda inst: \
"Successfully created/updated SSH Aggregate %s" % inst.name,
)
def create(request):
def pre_save(instance, created):
instance.owner = request.user
return generic_crud(
request,
obj_id=None,
model=DummyAggregate,
form_class=DummyAggForm,
pre_save=pre_save,
redirect=lambda(instance): "/",
template="aggregate_tests/form.html",
)
def aggregate_crud(request, agg_id=None):
"""Show a page for the user to add/edit an SSH aggregate in Expedient."""
return generic_crud(
request,
obj_id=agg_id,
model=SSHAggregate,
template_object_name="aggregate",
template="sshaggregate/aggregate_crud.html",
redirect=lambda inst: reverse(
aggregate_add_servers, args=[inst.id]),
success_msg=lambda inst: \
"Successfully created/updated SSH Aggregate %s" % inst.name,
)
def create(request, proj_id):
'''Create a slice'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_create_slices")
#<UT>
user_profile = UserProfile.get_or_create_profile(request.user)
user_urn = user_profile.urn
user_cert = user_profile.certificate
def pre_save(instance, created):
instance.project = project
instance.owner = request.user
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
#<UT>
instance.urn = 'n/a'
#import pdb; pdb.set_trace()
if settings.ENABLE_CBAS:
slice_urn = create_slice(owner_urn=user_urn, owner_certificate=user_cert, slice_name=instance.name,
slice_desc=instance.description, slice_project_urn=str(project.urn))
if slice_urn:
instance.urn = slice_urn
instance.save()
instance.reserved = False
#use to give the can_delete_slices over the slice to the creator and the owners of the project
def post_save(instance, created):
give_permission_to("can_delete_slices", instance, instance.owner, giver=None, can_delegate=False)
# for projectOwner in instance.project._get_owners():
# give_permission_to("can_delete_slices", instance, projectOwner, giver=None, can_delegate=False)
return generic_crud(
request, None, Slice,
TEMPLATE_PATH+"/create_update.html",
redirect=lambda instance:reverse("slice_detail", args=[instance.id]),
form_class=SliceCrudForm,
extra_context={
"project": project,
"title": "Create slice",
"cancel_url": reverse("project_detail", args=[proj_id]),
},
pre_save=pre_save,
post_save=post_save,
success_msg = lambda instance: "Successfully created slice %s." % instance.name,
)
def create(request, proj_id):
'''Create a slice'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_create_slices")
#<UT>
from expedient.clearinghouse.users.models import UserProfile
user_credentials = UserProfile.get_or_create_profile(request.user).credentials
def pre_save(instance, created):
instance.project = project
instance.owner = request.user
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
#<UT>
instance.credentials = 'n/a'
if ENABLE_CBAS:
code, values, output = create_slice(slice_name=instance.name, slice_desc=instance.description, user_credentials=[{'SFA': user_credentials}])
if code == 0 and 'SLICE_CREDENTIAL' in values:
instance.credentials = values.SLICE_CREDENTIAL
#import pdb; pdb.set_trace()
instance.save()
instance.reserved = False
#use to give the can_delete_slices over the slice to the creator and the owners of the project
def post_save(instance, created):
give_permission_to("can_delete_slices", instance, instance.owner, giver=None, can_delegate=False)
# for projectOwner in instance.project._get_owners():
# give_permission_to("can_delete_slices", instance, projectOwner, giver=None, can_delegate=False)
return generic_crud(
request, None, Slice,
TEMPLATE_PATH+"/create_update.html",
redirect=lambda instance:reverse("slice_detail", args=[instance.id]),
form_class=SliceCrudForm,
extra_context={
"project": project,
"title": "Create slice",
"cancel_url": reverse("project_detail", args=[proj_id]),
},
pre_save=pre_save,
post_save=post_save,
success_msg = lambda instance: "Successfully created slice %s." % instance.name,
)
def create(request, proj_id):
'''Create a slice'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_create_slices")
#<UT>
from expedient.clearinghouse.users.models import UserProfile
user_credentials = UserProfile.get_or_create_profile(request.user).credentials
def pre_save(instance, created):
instance.project = project
instance.owner = request.user
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
#<UT>
#print "--------------------"
code, values, output = create_slice(slice_name=instance.name, slice_desc=instance.description, user_credentials=user_credentials)
if code == 0 and 'SLICE_CREDENTIAL' in values:
instance.credentials = values.SLICE_CREDENTIAL
import pdb; pdb.set_trace()
instance.save()
instance.reserved = False
#use to give the can_delete_slices over the slice to the creator and the owners of the project
def post_save(instance, created):
give_permission_to("can_delete_slices", instance, instance.owner, giver=None, can_delegate=False)
# for projectOwner in instance.project._get_owners():
# give_permission_to("can_delete_slices", instance, projectOwner, giver=None, can_delegate=False)
return generic_crud(
request, None, Slice,
TEMPLATE_PATH+"/create_update.html",
redirect=lambda instance:reverse("slice_detail", args=[instance.id]),
form_class=SliceCrudForm,
extra_context={
"project": project,
"title": "Create slice",
"cancel_url": reverse("project_detail", args=[proj_id]),
},
pre_save=pre_save,
post_save=post_save,
success_msg = lambda instance: "Successfully created slice %s." % instance.name,
)
def update(request, slice_id):
'''Update a slice's information'''
project = get_object_or_404(Project, slice__pk=slice_id)
must_have_permission(request.user, project, "can_edit_slices")
return generic_crud(
request, slice_id, Slice,
TEMPLATE_PATH+"/create_update.html",
redirect=lambda instance:reverse("slice_detail", args=[instance.id]),
extra_context={
"title": "Create slice",
"cancel_url": reverse("slice_detail", args=[slice_id]),
},
form_class=SliceCrudForm,
success_msg = lambda instance: "Successfully updated slice %s." % instance.name,
)
def create(request):
'''Create a new project'''
def post_save(instance, created):
# Create default roles in the project
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
create_project_roles(instance, request.user)
instance.save()
#if settings.LDAP_STORE_PROJECTS:
# instance.sync_netgroup_ldap()
def redirect(instance):
return reverse("project_detail", args=[instance.id])
try:
return generic_crud(
request,
None,
model=Project,
form_class=ProjectCreateForm,
template=TEMPLATE_PATH + "/create_update.html",
post_save=post_save,
redirect=redirect,
template_object_name="project",
extra_context={
"breadcrumbs": (
("Home", reverse("home")),
("Create Project", request.path),
),
},
success_msg=lambda instance: "Successfully created project %s." %
instance.name,
)
except Exception as e:
if isinstance(e, ldap.LDAPError):
DatedMessage.objects.post_message_to_user(
"Project has been created but only locally since LDAP is not reachable. You will not be able to add users to the project until connection is restored.",
request.user,
msg_type=DatedMessage.TYPE_ERROR)
else:
DatedMessage.objects.post_message_to_user(
"Project may have been created, but some problem ocurred: %s" %
str(e),
request.user,
msg_type=DatedMessage.TYPE_ERROR)
return HttpResponseRedirect(reverse("home"))
def aggregate_create(request, agg_model,
redirect=lambda inst: reverse("home")):
'''
Create a GENI Aggregate.
@param request: The request.
@param model: The child subclass for the aggregate.
@keyword redirect: Function that takes the created instance and returns
a url to redirect to.
'''
def pre_save(instance, created):
instance.owner = request.user
def post_save(instance, created):
instance.update_resources()
give_permission_to(
"can_use_aggregate",
instance,
request.user,
can_delegate=True
)
give_permission_to(
"can_edit_aggregate",
instance,
request.user,
can_delegate=True
)
def success_msg(instance):
return "Successfully created aggregate %s." % instance.name
return generic_crud(
request, obj_id=None, model=agg_model,
template="aggregate_crud.html",
redirect=redirect,
form_class=geni_aggregate_form_factory(agg_model),
pre_save=pre_save,
post_save=post_save,
extra_context={
"create": True,
"name": agg_model._meta.verbose_name,
},
success_msg=success_msg)
def create(request, proj_id):
'''Create a slice'''
project = get_object_or_404(Project, id=proj_id)
must_have_permission(request.user, project, "can_create_slices")
def pre_save(instance, created):
instance.project = project
instance.owner = request.user
#Generate UUID: fixes caching problem on model default value
instance.uuid = uuid.uuid4()
instance.save()
instance.reserved = False
#use to give the can_delete_slices over the slice to the creator and the owners of the project
def post_save(instance, created):
give_permission_to("can_delete_slices",
instance,
instance.owner,
giver=None,
can_delegate=False)
# for projectOwner in instance.project._get_owners():
# give_permission_to("can_delete_slices", instance, projectOwner, giver=None, can_delegate=False)
return generic_crud(
request,
None,
Slice,
TEMPLATE_PATH + "/create_update.html",
redirect=lambda instance: reverse("slice_detail", args=[instance.id]),
form_class=SliceCrudForm,
extra_context={
"project": project,
"title": "Create slice",
"cancel_url": reverse("project_detail", args=[proj_id]),
},
pre_save=pre_save,
post_save=post_save,
success_msg=lambda instance: "Successfully created slice %s." %
instance.name,
)
def update(request, role_id):
"""Update the permissions in the role"""
role = get_object_or_404(ProjectRole, pk=role_id)
# require permission to proceed
must_have_permission(request.user, role.project, "can_edit_roles")
permittee = Permittee.objects.get_as_permittee(request.user)
initial_set = list(role.obj_permissions.values_list("pk", flat=True))
# Get the permissions that the user can delegate to others as well
# as the ones that are already in the role.
obj_permissions = ObjectPermission.objects.filter_from_instance(
role.project).filter(
Q(permissionownership__permittee=permittee,
permissionownership__can_delegate=True) | Q(id__in=initial_set))
project_url = reverse("project_detail", args=[role.project.id])
return generic_crud(request,
obj_id=role_id,
model=ProjectRole,
template=TEMPLATE_PATH + "/update.html",
redirect=lambda instance: project_url,
template_object_name="role",
form_class=ProjectRoleForm,
extra_form_params={
"obj_permissions": obj_permissions,
},
extra_context={
"project":
role.project,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % role.project.name,
project_url),
("Update Role %s" % role.name, request.path),
)
})
def aggregate_create(request, agg_model,
redirect=lambda inst: reverse("home")):
'''
Create a GENI Aggregate.
@param request: The request.
@param model: The child subclass for the aggregate.
@keyword redirect: Function that takes the created instance and returns
a url to redirect to.
'''
def pre_save(instance, created):
instance.owner = request.user
def post_save(instance, created):
instance.update_resources()
give_permission_to("can_use_aggregate",
instance,
request.user,
can_delegate=True)
give_permission_to("can_edit_aggregate",
instance,
request.user,
can_delegate=True)
def success_msg(instance):
return "Successfully created aggregate %s." % instance.name
return generic_crud(request,
obj_id=None,
model=agg_model,
template=TEMPLATE_PATH + "/aggregate_crud.html",
redirect=redirect,
form_class=geni_aggregate_form_factory(agg_model),
pre_save=pre_save,
post_save=post_save,
extra_context={
"create": True,
"name": agg_model._meta.verbose_name,
},
success_msg=success_msg)
def add_controller_to_slice(request, agg_id, slice_id):
"""Perform the actual add_controllr_to_slice request."""
aggregate = get_object_or_404(OpenFlowAggregate, id=agg_id)
slice = get_object_or_404(Slice, id=slice_id)
must_have_permission(request.user, aggregate, "can_use_aggregate")
must_have_permission(slice.project, aggregate, "can_use_aggregate")
next = request.GET.get("next", None)
# check if there's info already.
try:
info = OpenFlowSliceInfo.objects.get(slice=slice)
except OpenFlowSliceInfo.DoesNotExist:
info = None
id = info.id if info else None
creating = info != None
def pre_save(instance, created):
instance.slice = slice
def post_save(instance, created):
give_permission_to("can_use_aggregate", aggregate, slice)
return generic_crud(
request, id, OpenFlowSliceInfo,
form_class=OpenFlowSliceInfoForm,
template=TEMPLATE_PATH+"/aggregate_add_to_slice.html",
redirect=lambda instance: next if next else reverse(
"slice_detail", args=[slice.id]),
extra_context={"creating": creating,
"slice": slice,
"aggregate": aggregate},
template_object_name="info",
pre_save=pre_save,
post_save=post_save,
success_msg=lambda instance: "Successfully added OpenFlow controller to slice %s" % (slice.name),
)
def create(request):
'''
Create a new message
'''
if request.user.is_superuser:
message_class = MessageForm
else:
message_class = MessageFormNoIM
# Original
# return create_message(
# request,
# form_class=message_class,
# template_name="expedient/common/messaging/create.html",
# post_save_redirect=reverse("messaging_created"),
# )
return generic_crud(
request, None, None,"expedient/common/messaging/create.html",
redirect=lambda instance:reverse("messaging_center"),
form_class=message_class,
success_msg = lambda instance: "Successfully sent message.",
)
def resource_crud(request, slice_id, agg_id, resource_id = None):
"""
Show a page that allows user to create/edit SampleResource's to the Aggregate.
"""
slice = get_object_or_404(Slice, id = slice_id)
aggregate = Aggregate.objects.get(id = agg_id)
error_crud = ""
def pre_save(instance, created):
"""
Fills SampleResource instance prior to its saving.
Used within the scope of the generic_crud method.
"""
instance = SampleResourceController.fill(instance, slice, agg_id, resource_id)
try:
return generic_crud(request, obj_id=resource_id, model=SampleResourceModel,
form_class=SampleResourceModelForm,
template="sample_resource_resource_crud.html",
redirect=lambda inst: reverse("slice_detail", args=[slice_id]),
extra_context={"agg": aggregate, "slice": slice, "exception": error_crud, "breadcrumbs": (
("Home", reverse("home")),
("Project %s" % slice.project.name, reverse("project_detail", args=[slice.project.id])),
("Slice %s" % slice.name, reverse("slice_detail", args=[slice_id])),
("%s SampleResource" % "Update" if resource_id else "Create", reverse("sample_resource_resource_crud", args=[slice_id, agg_id])),)
}, extra_form_params={}, template_object_name="object", pre_save=pre_save,
post_save=None, success_msg=None)
except ValidationError as e:
# Django exception message handling is different to Python's...
error_crud = ";".join(e.messages)
except Exception as e:
print "[WARNING] Could not create resource in plugin 'sample_resource'. Details: %s" % str(e)
DatedMessage.objects.post_message_to_user(
"SampleResource might have been created, but some problem ocurred: %s" % str(e),
request.user, msg_type=DatedMessage.TYPE_ERROR)
return HttpResponseRedirect(reverse("slice_detail", args=[slice_id]))
def create(request, proj_id):
"""Create a new role for a project."""
project = get_object_or_404(Project, pk=proj_id)
# require permission to proceed
must_have_permission(request.user, project, "can_create_roles")
obj_permissions = ObjectPermission.objects.filter_from_instance(project)
project_url = reverse("project_detail", args=[project.id])
def pre_save(instance, created):
instance.project = project
return generic_crud(
request,
obj_id=None,
model=ProjectRole,
template=TEMPLATE_PATH+"/create.html",
redirect=lambda instance: project_url,
form_class=ProjectRoleForm,
pre_save=pre_save,
extra_form_params={
"obj_permissions": obj_permissions,
},
extra_context={
"project": project,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % project.name,
project_url),
("Create Role", request.path),
)
}
)
for agg in Aggregate.objects.all():
agg = agg.as_leaf_class()
if agg.leaf_name == "OpenFlowAggregate":
agg.change_slice_controller(slice)
except Exception,e:
error_msg = str(e)
print e
return generic_crud(
request, id, OpenFlowSliceInfo,
# form_class=OpenFlowSliceInfoForm,
form_class=OpenFlowSliceControllerForm,
extra_form_params={"slice": slice},
template="openflow_aggregate_add_to_slice.html",
redirect=lambda instance: next if next else reverse(
"slice_detail", args=[slice.id]),
extra_context={"creating": creating,
"slice": slice,
"aggregate": aggregate},
template_object_name="info",
pre_save=pre_save,
post_save=post_save,
success_msg=lambda instance: "Successfully added OpenFlow controller to slice %s" % (slice.name),
)
def remove_controller_from_slice(request, agg_id, slice_id):
"""Perform the actual remove_controller_from_slice request."""
aggregate = get_object_or_404(OpenFlowAggregate, id=agg_id)
slice = get_object_or_404(Slice, id=slice_id)
must_have_permission(request.user, aggregate, "can_use_aggregate")
must_have_permission(slice.project, aggregate, "can_use_aggregate")
agg.change_slice_controller(slice)
except Exception, e:
error_msg = str(e)
print e
return generic_crud(
request,
id,
OpenFlowSliceInfo,
# form_class=OpenFlowSliceInfoForm,
form_class=OpenFlowSliceControllerForm,
extra_form_params={"slice": slice},
template="openflow_aggregate_add_to_slice.html",
redirect=lambda instance: next
if next else reverse("slice_detail", args=[slice.id]),
extra_context={
"creating": creating,
"slice": slice,
"aggregate": aggregate
},
template_object_name="info",
pre_save=pre_save,
post_save=post_save,
success_msg=lambda instance:
"Successfully added OpenFlow controller to slice %s" % (slice.name),
)
def remove_controller_from_slice(request, agg_id, slice_id):
"""Perform the actual remove_controller_from_slice request."""
aggregate = get_object_or_404(OpenFlowAggregate, id=agg_id)
