def add_management(request, obj_type, obj_ref, obj_revi, reader=False, level=None):
"""
View to add a manager (notified user or restricted reader).
:url: :samp:`/object/{obj_type}/{obj_ref}/{obj_revi}/management/add/`
or
:url: :samp:`/object/{obj_type}/{obj_ref}/{obj_revi}/management/add-reader/`
.. include:: views_params.txt
:param reader: True to add a restricted reader instead of a notified user
**Template:**
:file:`management_replace.html`
**Context:**
``RequestContext``
``replace_manager_form``
a form to select the new manager (a user)
``link_creation``
Set to True
``role``
role of the new user (:const:`.ROLE_NOTIFIED` or :const:`.ROLE_READER`)
``attach``
set to (*obj*, :samp:`"add_{role}"`)
"""
obj, ctx = get_generic_data(request, obj_type, obj_ref, obj_revi)
if level is None:
role = models.ROLE_READER if reader else models.ROLE_NOTIFIED
else:
role = level_to_sign_str(int(level))
if request.method == "POST":
add_management_form = forms.SelectUserForm(request.POST)
if add_management_form.is_valid():
if add_management_form.cleaned_data["type"] == "User":
user_obj = get_obj_from_form(add_management_form, request.user)
obj.set_role(user_obj.object, role)
message = _(u"Role %(add_role)s granted." % dict(add_role=role))
messages.info(request, message)
return HttpResponseRedirect("../../lifecycle/")
else:
add_management_form = forms.SelectUserForm()
ctx.update({'current_page':'lifecycle',
'replace_manager_form': add_management_form,
'link_creation': True,
'role' : role,
"attach" : (obj, "add_" + role)})
return r2r('management_replace.html', ctx, request)
def replace_management(request, obj_type, obj_ref, obj_revi, link_id):
"""
View to replace a manager (owner, signer, reader...) by another one.
:url: :samp:`/object/{obj_type}/{obj_ref}/{obj_revi}/management/replace/{link_id}/`
.. include:: views_params.txt
:param link_id: id of the :class:`.PLMObjectUserLink` being replaced
**Template:**
:file:`management_replace.html`
**Context:**
``RequestContext``
``replace_manager_form``
a form to select the new manager (a user)
``link_creation``
Set to True
``role``
role of the link being replace
``attach``
set to (*obj*, :samp:`"add_{role}"`)
"""
obj, ctx = get_generic_data(request, obj_type, obj_ref, obj_revi)
link = obj.users.now().get(id=int(link_id))
if request.method == "POST":
replace_manager_form = forms.SelectUserForm(request.POST)
if replace_manager_form.is_valid():
if replace_manager_form.cleaned_data["type"] == "User":
user_obj = get_obj_from_form(replace_manager_form, request.user)
if link.role.startswith(models.ROLE_SIGN):
obj.replace_signer(link.user, user_obj.object, link.role)
else:
obj.set_role(user_obj.object, link.role)
if link.role == models.ROLE_NOTIFIED:
obj.remove_notified(link.user)
elif link.role == models.ROLE_READER:
obj.remove_reader(link.user)
return HttpResponseRedirect("../../../lifecycle/")
else:
replace_manager_form = forms.SelectUserForm()
ctx.update({'current_page':'lifecycle',
'replace_manager_form': replace_manager_form,
'link_creation': True,
'role' : link.role,
'attach' : (obj, "add_" + link.role)})
return r2r('management_replace.html', ctx, request)
def delegate(request, obj_ref, role, sign_level):
"""
Manage html page for delegations modification of the selected
:class:`~django.contrib.auth.models.User`.
It computes a context dictionary based on
:param request: :class:`django.http.QueryDict`
:param obj_type: :class:`~django.contrib.auth.models.User`
:type obj_ref: str
:param role: :attr:`.DelegationLink.role` if role is not "sign"
:type role: str
:param sign_level: used for :attr:`.DelegationLink.role` if role is "sign"
:type sign_level: str
:return: a :class:`django.http.HttpResponse`
"""
obj, ctx = get_generic_data(request, "User", obj_ref)
if request.method == "POST":
delegation_form = forms.SelectUserForm(request.POST)
if delegation_form.is_valid():
if delegation_form.cleaned_data["type"] == "User":
user_obj = get_obj_from_form(delegation_form, request.user)
if role == "notified" or role == "owner":
obj.delegate(user_obj.object, role)
return HttpResponseRedirect("../..")
elif role == "sign":
if sign_level == "all":
obj.delegate(user_obj.object, "sign*")
return HttpResponseRedirect("../../..")
elif sign_level.isdigit():
obj.delegate(user_obj.object,
level_to_sign_str(int(sign_level) - 1))
return HttpResponseRedirect("../../..")
else:
delegation_form = forms.SelectUserForm()
if role == 'sign':
if sign_level.isdigit():
role = _("signer level") + " " + str(sign_level)
else:
role = _("signer all levels")
elif role == "notified":
role = _("notified")
ctx.update({
'current_page': 'delegation',
'replace_manager_form': delegation_form,
'link_creation': True,
'attach': (obj, "delegate"),
'role': role
})
return r2r('management_replace.html', ctx, request)
def get_management_data(obj, user):
"""
Returns a dictionary containing management data for *obj*.
:param user: User who runs the request
**Dictionary content**
``notified_list``
List of notification :class:`.PLMObjectUserLink` related to *obj*
``owner_list``
List of owner :class:`.PLMObjectUserLink` related to *obj*
``reader_list``
List of restricted reader :class:`.PLMObjectUserLink` related to *obj*
If *user* does not own *obj*:
``is_notified``
True if *user* receives notifications when *obj* changes
``remove_notify_link``
(set if *is_notified* is True)
Notification :class:`.PLMObjectUserLink` between *obj* and *user*
``can_notify``
True if *user* can ask to receive notifications when *obj* changes
``notify_self_form``
(set if *can_notify* is True)
form to notify *user*
"""
ctx = {}
# evaluates now PLMObjectLinks to make one sql query
links = list(obj.users.now().select_related("user"))
if not obj.check_permission("owner", False):
link = [l for l in links if l.role == models.ROLE_NOTIFIED and l.user == user]
ctx["is_notified"] = bool(link)
if link:
ctx["remove_notify_link"] = link[0]
else:
if obj.check_in_group(user, False):
initial = dict(type="User", username=user.username)
form = forms.SelectUserForm(initial=initial)
for field in ("type", "username"):
form.fields[field].widget = HiddenInput()
ctx["notify_self_form"] = form
ctx["can_notify"] = True
else:
ctx["can_notify"] = False
ctx.update({
'notified_list' : [l for l in links if l.role == models.ROLE_NOTIFIED],
'owner_list' :[l for l in links if l.role == models.ROLE_OWNER],
'reader_list' :[l for l in links if l.role == models.ROLE_READER],
})
return ctx
def group_add_user(request, obj_ref):
"""
View of the *Add user* page of a group.
"""
obj, ctx = get_generic_data(request, "Group", obj_ref)
if request.method == "POST":
form = forms.SelectUserForm(request.POST)
if form.is_valid():
guest = User.objects.get(username=form.cleaned_data["username"])
obj.add_user(guest)
msg = _("Invitation sent to %(name)s") % {
"name": guest.get_full_name()
}
messages.info(request, msg)
return HttpResponseRedirect("..")
else:
form = forms.SelectUserForm()
ctx["add_user_form"] = form
ctx['current_page'] = 'users'
ctx['link_creation'] = True
return r2r("groups/add_user.html", ctx, request)