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 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)