1957057914

Build # 1957057914

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/HewlettPackard/squest/commit/<a class=hub.com/HewlettPackard/squest/commit/bfa3f9a0f54601fe7607036dd13b351c8d00d025">bfa3f9a0f<a href="https://github.com/HewlettPackard/squest/commit/bfa3f9a0f54601fe7607036dd13b351c8d00d025">">Merge </a><a class="double-link" href="https://github.com/HewlettPackard/squest/commit/<a class="double-link" href="https://github.com/HewlettPackard/squest/commit/7af2c4e25ce205761687a8dba8c2effcffbcf8d8">7af2c4e25</a>">7af2c4e25</a><a href="https://github.com/HewlettPackard/squest/commit/bfa3f9a0f54601fe7607036dd13b351c8d00d025"> into 4efb27897">4efb27897</a>

Pull Request Pull Request #415: [Feature] Message can be edited

Run Details

37 of 37 new or added lines in 4 files covered. (100.0%)

6385 of 6833 relevant lines covered (93.44%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.1

/service_catalog/views/instance.py

from django.contrib.auth.decorators import user_passes_test, login_required
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import PermissionDenied
from django.shortcuts import render, get_object_or_404, redirect
from django.urls import reverse
from django.utils.safestring import mark_safe
from django_fsm import can_proceed
from guardian.decorators import permission_required_or_403

from profiles.forms import UserRoleForObjectForm, TeamRoleForObjectForm
from profiles.models import Role, Team
from profiles.tables import TeamsByObjectTable
from profiles.tables import UserByObjectTable
from service_catalog.forms import InstanceForm, OperationRequestForm, SupportRequestForm, SupportMessageForm
from service_catalog.models import Instance, Support, Operation, InstanceState, OperationType, SupportMessage, Request
from service_catalog.tables.operation_tables import OperationTableFromInstanceDetails
from service_catalog.tables.request_tables import RequestTable
from service_catalog.views.support_list_view import SupportTable


@user_passes_test(lambda u: u.is_superuser)
def instance_edit(request, instance_id):
    instance = get_object_or_404(Instance, id=instance_id)
    form = InstanceForm(request.POST or None, request.FILES or None, instance=instance)
    if form.is_valid():
        form.save()
        return redirect('service_catalog:instance_details', instance.id)
    context = {
        'form': form,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{instance.name} ({instance.id})",
             'url': reverse('service_catalog:instance_details', args=[instance_id])},
        ],
        'object_name': 'instance'}
    return render(request, 'generics/edit-sensitive-object.html', context)


@user_passes_test(lambda u: u.is_superuser)
def instance_delete(request, instance_id):
    instance = get_object_or_404(Instance, id=instance_id)
    if request.method == 'POST':
        instance.delete()
        return redirect("service_catalog:instance_list")
    args = {
        "instance_id": instance_id,
    }
    context = {
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{instance.name} ({instance.id})",
             'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': 'Delete', 'url': ''}
        ],
        'confirm_text': mark_safe(f"Confirm deletion of <strong>{instance.name}</strong>?"),
        'action_url': reverse('service_catalog:instance_delete', kwargs=args),
        'button_text': 'Delete',
        'details':
            {
                'warning_sentence': 'Warning: all requests related to this instance will be deleted:',
                'details_list': [f"ID: {request.id}, State: {request.state}" for request in instance.request_set.all()]
            } if instance.request_set.count() != 0 else None
    }
    return render(request, 'generics/confirm-delete-template.html', context=context)


@login_required
@permission_required_or_403('service_catalog.request_operation_on_instance', (Instance, 'id', 'instance_id'))
def instance_request_new_operation(request, instance_id, operation_id):
    instance = get_object_or_404(Instance, id=instance_id)
    if instance.state not in [InstanceState.AVAILABLE, InstanceState.UPDATING]:
        raise PermissionDenied
    operation = get_object_or_404(Operation, id=operation_id)
    allowed_operations = Operation.objects.filter(service=instance.service,
                                                  type__in=[OperationType.UPDATE, OperationType.DELETE])
    if operation not in allowed_operations:
        raise PermissionDenied
    parameters = {
        'operation_id': operation_id,
        'instance_id': instance_id
    }
    if request.method == 'POST':
        form = OperationRequestForm(request.user, request.POST, **parameters)
        if form.is_valid():
            form.save()
            return redirect('service_catalog:request_list')
    else:
        form = OperationRequestForm(request.user, **parameters)
    context = {
        'form': form,
        'operation': operation,
        'instance': instance,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{instance.name} ({instance.id})",
             'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': f"Operation - {operation.name}", 'url': ''}
        ],
        'icon_button': "fas fa-shopping-cart",
        'text_button': "Request the operation",
        'color_button': "success"
    }
    return render(request, 'generics/generic_form.html', context)


@login_required
@permission_required_or_403('service_catalog.delete_instance', (Instance, 'id', 'instance_id'))
def instance_archive(request, instance_id):
    target_instance = get_object_or_404(Instance, id=instance_id)
    if request.method == "POST":
        if not can_proceed(target_instance.archive):
            raise PermissionDenied
        target_instance.archive()
        target_instance.save()

        return redirect('service_catalog:instance_list')
    context = {
        "instance": target_instance
    }
    return render(request, "service_catalog/customer/instance/instance-archive.html", context)


@login_required
@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))
def instance_new_support(request, instance_id):
    target_instance = get_object_or_404(Instance, id=instance_id)
    parameters = {
        'instance_id': instance_id
    }
    if request.method == 'POST':
        form = SupportRequestForm(request.user, request.POST, **parameters)
        if form.is_valid():
            form.save()
            return redirect(reverse('service_catalog:instance_details', args=[target_instance.id]) + "#support")
    else:
        form = SupportRequestForm(request.user, **parameters)
    context = {
        'form': form,
        'instance': target_instance,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{target_instance.name} ({target_instance.id})", 'url': reverse('service_catalog:instance_details', args=[instance_id])},
        ],
        'color_button': 'success',
        'text_button': 'Open new support',
        'icon_button': 'fas fa-plus'
    }
    return render(request, 'generics/generic_form.html', context)


@login_required
@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))
def instance_support_details(request, instance_id, support_id):
    instance = get_object_or_404(Instance, id=instance_id)
    support = get_object_or_404(Support, id=support_id)
    messages = SupportMessage.objects.filter(support=support)
    if request.method == "POST":
        form = SupportMessageForm(request.POST or None, sender=request.user, support=support)
        if "btn_close" in request.POST:
            if not can_proceed(support.do_close):
                raise PermissionDenied
            support.do_close()
            support.save()
        if "btn_re_open" in request.POST:
            if not can_proceed(support.do_open):
                raise PermissionDenied
            support.do_open()
            support.save()
        if form.is_valid():
            if form.cleaned_data["content"] is not None and form.cleaned_data["content"] != "":
                form.save()
            return redirect('service_catalog:instance_support_details', instance.id, support.id)
    else:
        form = SupportMessageForm(sender=request.user, support=support)
    context = {
        "form": form,
        "instance": instance,
        "messages": messages,
        "support": support,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{instance.name} ({instance.id})",
             'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': 'Support', 'url': ""},
            {'text': support.title, 'url': ""},
        ]
    }
    return render(request, "service_catalog/common/instance-support-details.html", context)


@login_required
@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))
def support_message_edit(request, instance_id, support_id, message_id):
    support_message = get_object_or_404(SupportMessage, id=message_id)
    if request.method == "POST":
        form = SupportMessageForm(request.POST or None, request.FILES or None, sender=support_message.sender,
                                  support=support_message.support, instance=support_message)
        if form.is_valid():
            form.save()
            return redirect('service_catalog:instance_support_details', support_message.support.instance.id,
                            support_message.support.id)
    else:
        form = SupportMessageForm(sender=request.user, support=support_message.support, instance=support_message)
    context = {
        'form': form,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': f"{support_message.support.instance.name} ({support_message.support.instance.id})",
             'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': 'Support', 'url': ""},
            {'text': support_message.support.title,
             'url': reverse('service_catalog:instance_support_details',
                            kwargs={'instance_id': instance_id, 'support_id': support_id})},
        ],
        'action': 'edit'
    }
    return render(request, "generics/generic_form.html", context)


@login_required
@permission_required_or_403('service_catalog.view_instance', (Instance, 'id', 'instance_id'))
def instance_details(request, instance_id):
    instance = get_object_or_404(Instance, id=instance_id)
    supports = Support.objects.filter(instance=instance)
    operations = Operation.objects.filter(service=instance.service,
                                          type__in=[OperationType.UPDATE, OperationType.DELETE])
    requests = Request.objects.filter(instance=instance)
    operations_table = OperationTableFromInstanceDetails(operations)
    requests_table = RequestTable(requests,
                                  hide_fields=["instance__name", "instance__service__name"])
    supports_table = SupportTable(supports, hide_fields=["instance__name"])

    users_table = UserByObjectTable(instance.get_all_users())
    teams_table = TeamsByObjectTable(instance.get_all_teams())
    context = {'instance': instance,
               'operations_table': operations_table,
               'requests_table': requests_table,
               'supports_table': supports_table,
               'users_table': users_table,
               'teams_table': teams_table,
               'user_roles': instance.get_roles_of_users(),
               'team_roles': instance.get_roles_of_teams(),
               'app_name': 'service_catalog',
               'object': instance,
               'object_name': 'instance',
               'object_id': instance.id,
               'breadcrumbs': [
                   {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
                   {'text': f"{instance.name} ({instance.id})", 'url': ""},
               ],
               }
    return render(request, 'service_catalog/common/instance-details.html', context=context)


@login_required
@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))
def user_in_instance_update(request, instance_id):
    instance = get_object_or_404(Instance, id=instance_id)
    form = UserRoleForObjectForm(request.POST or None, object=instance)
    error = False
    if request.method == 'POST':
        if form.is_valid():
            users_id = form.cleaned_data.get('users')
            role_id = int(form.cleaned_data.get('roles'))
            role = Role.objects.get(id=role_id)
            current_users = instance.get_users_in_role(role.name)
            selected_users = [User.objects.get(id=user_id) for user_id in users_id]
            to_remove = list(set(current_users) - set(selected_users))
            to_add = list(set(selected_users) - set(current_users))
            if instance.spoc in to_remove and role.name == "Admin":
                form.add_error('users', 'SPOC cannot be removed from Admin')
                error = True
            if not error:
                for user in to_add:
                    instance.add_user_in_role(user, role.name)
                for user in to_remove:
                    instance.remove_user_in_role(user, role.name)
                return redirect(reverse("service_catalog:instance_details", args=[instance_id]) + "#users")
    context = {
        'form': form,
        'content_type_id': ContentType.objects.get_for_model(Instance).id,
        'object_id': instance.id,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': "Users", 'url': ""}
        ]
    }
    return render(request, 'profiles/role/user-role-for-object-form.html', context)


@login_required
@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))
def user_in_instance_remove(request, instance_id, user_id):
    instance = get_object_or_404(Instance, id=instance_id)
    user = User.objects.get(id=user_id)
    if user == instance.spoc:
        return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#users")
    if request.method == 'POST':
        instance.remove_user_in_role(user)
        return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#users")
    args = {
        "instance_id": instance_id,
        "user_id": user_id
    }
    context = {
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': "Users", 'url': ""}
        ],
        'confirm_text': mark_safe(f"Confirm to remove all roles of the user <strong>{user.username}</strong> from "
                                  f"{instance}?"),
        'action_url': reverse('service_catalog:user_in_instance_remove', kwargs=args),
        'button_text': 'Remove'
    }
    return render(request, 'generics/confirm-delete-template.html', context=context)


@login_required
@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))
def team_in_instance_update(request, instance_id):
    instance = get_object_or_404(Instance, id=instance_id)
    form = TeamRoleForObjectForm(request.POST or None, user=request.user, object=instance)
    if request.method == 'POST':
        if form.is_valid():
            form.save()
            return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#teams")
    context = {
        'form': form,
        'content_type_id': ContentType.objects.get_for_model(Instance).id,
        'object_id': instance.id,
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': "Teams", 'url': ""}
        ]
    }
    return render(request, 'profiles/role/team-role-for-object-form.html', context)


@login_required
@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))
def team_in_instance_remove(request, instance_id, team_id):
    instance = get_object_or_404(Instance, id=instance_id)
    team = Team.objects.get(id=team_id)
    if request.method == 'POST':
        instance.remove_team_in_role(team)
        return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#teams")
    args = {
        "instance_id": instance_id,
        "team_id": team_id
    }
    context = {
        'breadcrumbs': [
            {'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
            {'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
            {'text': "Teams", 'url': ""}
        ],
        'confirm_text': mark_safe(f"Confirm to remove all roles of the team <strong>{team.name}</strong> on "
                                  f"{instance}?"),
        'action_url': reverse('service_catalog:team_in_instance_remove', kwargs=args),
        'button_text': 'Remove'
    }
    return render(request, 'generics/confirm-delete-template.html', context=context)

1	from django.contrib.auth.decorators import user_passes_test, login_required	1✔
2	from django.contrib.auth.models import User	1✔
3	from django.contrib.contenttypes.models import ContentType	1✔
4	from django.core.exceptions import PermissionDenied	1✔
5	from django.shortcuts import render, get_object_or_404, redirect	1✔
6	from django.urls import reverse	1✔
7	from django.utils.safestring import mark_safe	1✔
8	from django_fsm import can_proceed	1✔
9	from guardian.decorators import permission_required_or_403	1✔
10
11	from profiles.forms import UserRoleForObjectForm, TeamRoleForObjectForm	1✔
12	from profiles.models import Role, Team	1✔
13	from profiles.tables import TeamsByObjectTable	1✔
14	from profiles.tables import UserByObjectTable	1✔
15	from service_catalog.forms import InstanceForm, OperationRequestForm, SupportRequestForm, SupportMessageForm	1✔
16	from service_catalog.models import Instance, Support, Operation, InstanceState, OperationType, SupportMessage, Request	1✔
17	from service_catalog.tables.operation_tables import OperationTableFromInstanceDetails	1✔
18	from service_catalog.tables.request_tables import RequestTable	1✔
19	from service_catalog.views.support_list_view import SupportTable	1✔
20
21
22	@user_passes_test(lambda u: u.is_superuser)	1✔
23	def instance_edit(request, instance_id):	1✔
24	instance = get_object_or_404(Instance, id=instance_id)	1✔
25	form = InstanceForm(request.POST or None, request.FILES or None, instance=instance)	1✔
26	if form.is_valid():	1✔
27	form.save()	1✔
28	return redirect('service_catalog:instance_details', instance.id)	1✔
29	context = {	1✔
30	'form': form,
31	'breadcrumbs': [
32	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
33	{'text': f"{instance.name} ({instance.id})",
34	'url': reverse('service_catalog:instance_details', args=[instance_id])},
35	],
36	'object_name': 'instance'}
37	return render(request, 'generics/edit-sensitive-object.html', context)	1✔
38
39
40	@user_passes_test(lambda u: u.is_superuser)	1✔
41	def instance_delete(request, instance_id):	1✔
42	instance = get_object_or_404(Instance, id=instance_id)	1✔
43	if request.method == 'POST':	1✔
44	instance.delete()	1✔
45	return redirect("service_catalog:instance_list")	1✔
46	args = {	1✔
47	"instance_id": instance_id,
48	}
49	context = {	1✔
50	'breadcrumbs': [
51	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
52	{'text': f"{instance.name} ({instance.id})",
53	'url': reverse('service_catalog:instance_details', args=[instance_id])},
54	{'text': 'Delete', 'url': ''}
55	],
56	'confirm_text': mark_safe(f"Confirm deletion of <strong>{instance.name}</strong>?"),
57	'action_url': reverse('service_catalog:instance_delete', kwargs=args),
58	'button_text': 'Delete',
59	'details':
60	{
61	'warning_sentence': 'Warning: all requests related to this instance will be deleted:',
62	'details_list': [f"ID: {request.id}, State: {request.state}" for request in instance.request_set.all()]
63	} if instance.request_set.count() != 0 else None
64	}
65	return render(request, 'generics/confirm-delete-template.html', context=context)	1✔
66
67
68	@login_required	1✔
69	@permission_required_or_403('service_catalog.request_operation_on_instance', (Instance, 'id', 'instance_id'))	1✔
70	def instance_request_new_operation(request, instance_id, operation_id):	1✔
71	instance = get_object_or_404(Instance, id=instance_id)	1✔
72	if instance.state not in [InstanceState.AVAILABLE, InstanceState.UPDATING]:	1✔
73	raise PermissionDenied	1✔
74	operation = get_object_or_404(Operation, id=operation_id)	1✔
75	allowed_operations = Operation.objects.filter(service=instance.service,	1✔
76	type__in=[OperationType.UPDATE, OperationType.DELETE])
77	if operation not in allowed_operations:	1✔
78	raise PermissionDenied	1✔
79	parameters = {	1✔
80	'operation_id': operation_id,
81	'instance_id': instance_id
82	}
83	if request.method == 'POST':	1✔
84	form = OperationRequestForm(request.user, request.POST, **parameters)	1✔
85	if form.is_valid():	1✔
86	form.save()	1✔
87	return redirect('service_catalog:request_list')	1✔
88	else:
89	form = OperationRequestForm(request.user, **parameters)	×
90	context = {	×
91	'form': form,
92	'operation': operation,
93	'instance': instance,
94	'breadcrumbs': [
95	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
96	{'text': f"{instance.name} ({instance.id})",
97	'url': reverse('service_catalog:instance_details', args=[instance_id])},
98	{'text': f"Operation - {operation.name}", 'url': ''}
99	],
100	'icon_button': "fas fa-shopping-cart",
101	'text_button': "Request the operation",
102	'color_button': "success"
103	}
104	return render(request, 'generics/generic_form.html', context)	×
105
106
107	@login_required	1✔
108	@permission_required_or_403('service_catalog.delete_instance', (Instance, 'id', 'instance_id'))	1✔
109	def instance_archive(request, instance_id):	1✔
110	target_instance = get_object_or_404(Instance, id=instance_id)	1✔
111	if request.method == "POST":	1✔
112	if not can_proceed(target_instance.archive):	1✔
113	raise PermissionDenied	1✔
114	target_instance.archive()	1✔
115	target_instance.save()	1✔
116
117	return redirect('service_catalog:instance_list')	1✔
118	context = {	×
119	"instance": target_instance
120	}
121	return render(request, "service_catalog/customer/instance/instance-archive.html", context)	×
122
123
124	@login_required	1✔
125	@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))	1✔
126	def instance_new_support(request, instance_id):	1✔
127	target_instance = get_object_or_404(Instance, id=instance_id)	1✔
128	parameters = {	1✔
129	'instance_id': instance_id
130	}
131	if request.method == 'POST':	1✔
132	form = SupportRequestForm(request.user, request.POST, **parameters)	1✔
133	if form.is_valid():	1✔
134	form.save()	1✔
135	return redirect(reverse('service_catalog:instance_details', args=[target_instance.id]) + "#support")	1✔
136	else:
137	form = SupportRequestForm(request.user, **parameters)	×
138	context = {	×
139	'form': form,
140	'instance': target_instance,
141	'breadcrumbs': [
142	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
143	{'text': f"{target_instance.name} ({target_instance.id})", 'url': reverse('service_catalog:instance_details', args=[instance_id])},
144	],
145	'color_button': 'success',
146	'text_button': 'Open new support',
147	'icon_button': 'fas fa-plus'
148	}
149	return render(request, 'generics/generic_form.html', context)	×
150
151
152	@login_required	1✔
153	@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))	1✔
154	def instance_support_details(request, instance_id, support_id):	1✔
155	instance = get_object_or_404(Instance, id=instance_id)	1✔
156	support = get_object_or_404(Support, id=support_id)	1✔
157	messages = SupportMessage.objects.filter(support=support)	1✔
158	if request.method == "POST":	1✔
159	form = SupportMessageForm(request.POST or None, sender=request.user, support=support)	1✔
160	if "btn_close" in request.POST:	1✔
161	if not can_proceed(support.do_close):	1✔
162	raise PermissionDenied	×
163	support.do_close()	1✔
164	support.save()	1✔
165	if "btn_re_open" in request.POST:	1✔
166	if not can_proceed(support.do_open):	1✔
167	raise PermissionDenied	1✔
168	support.do_open()	1✔
169	support.save()	1✔
170	if form.is_valid():	1✔
171	if form.cleaned_data["content"] is not None and form.cleaned_data["content"] != "":	1✔
172	form.save()	1✔
173	return redirect('service_catalog:instance_support_details', instance.id, support.id)	1✔
174	else:
175	form = SupportMessageForm(sender=request.user, support=support)	1✔
176	context = {	1✔
177	"form": form,
178	"instance": instance,
179	"messages": messages,
180	"support": support,
181	'breadcrumbs': [
182	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
183	{'text': f"{instance.name} ({instance.id})",
184	'url': reverse('service_catalog:instance_details', args=[instance_id])},
185	{'text': 'Support', 'url': ""},
186	{'text': support.title, 'url': ""},
187	]
188	}
189	return render(request, "service_catalog/common/instance-support-details.html", context)	1✔
190
191
192	@login_required	1✔
193	@permission_required_or_403('service_catalog.request_support_on_instance', (Instance, 'id', 'instance_id'))	1✔
194	def support_message_edit(request, instance_id, support_id, message_id):	1✔
195	support_message = get_object_or_404(SupportMessage, id=message_id)	×
196	if request.method == "POST":	×
197	form = SupportMessageForm(request.POST or None, request.FILES or None, sender=support_message.sender,	×
198	support=support_message.support, instance=support_message)
199	if form.is_valid():	×
200	form.save()	×
201	return redirect('service_catalog:instance_support_details', support_message.support.instance.id,	×
202	support_message.support.id)
203	else:
204	form = SupportMessageForm(sender=request.user, support=support_message.support, instance=support_message)	×
205	context = {	×
206	'form': form,
207	'breadcrumbs': [
208	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
209	{'text': f"{support_message.support.instance.name} ({support_message.support.instance.id})",
210	'url': reverse('service_catalog:instance_details', args=[instance_id])},
211	{'text': 'Support', 'url': ""},
212	{'text': support_message.support.title,
213	'url': reverse('service_catalog:instance_support_details',
214	kwargs={'instance_id': instance_id, 'support_id': support_id})},
215	],
216	'action': 'edit'
217	}
218	return render(request, "generics/generic_form.html", context)	×
219
220
221	@login_required	1✔
222	@permission_required_or_403('service_catalog.view_instance', (Instance, 'id', 'instance_id'))	1✔
223	def instance_details(request, instance_id):	1✔
224	instance = get_object_or_404(Instance, id=instance_id)	1✔
225	supports = Support.objects.filter(instance=instance)	1✔
226	operations = Operation.objects.filter(service=instance.service,	1✔
227	type__in=[OperationType.UPDATE, OperationType.DELETE])
228	requests = Request.objects.filter(instance=instance)	1✔
229	operations_table = OperationTableFromInstanceDetails(operations)	1✔
230	requests_table = RequestTable(requests,	1✔
231	hide_fields=["instance__name", "instance__service__name"])
232	supports_table = SupportTable(supports, hide_fields=["instance__name"])	1✔
233
234	users_table = UserByObjectTable(instance.get_all_users())	1✔
235	teams_table = TeamsByObjectTable(instance.get_all_teams())	1✔
236	context = {'instance': instance,	1✔
237	'operations_table': operations_table,
238	'requests_table': requests_table,
239	'supports_table': supports_table,
240	'users_table': users_table,
241	'teams_table': teams_table,
242	'user_roles': instance.get_roles_of_users(),
243	'team_roles': instance.get_roles_of_teams(),
244	'app_name': 'service_catalog',
245	'object': instance,
246	'object_name': 'instance',
247	'object_id': instance.id,
248	'breadcrumbs': [
249	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
250	{'text': f"{instance.name} ({instance.id})", 'url': ""},
251	],
252	}
253	return render(request, 'service_catalog/common/instance-details.html', context=context)	1✔
254
255
256	@login_required	1✔
257	@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))	1✔
258	def user_in_instance_update(request, instance_id):	1✔
259	instance = get_object_or_404(Instance, id=instance_id)	×
260	form = UserRoleForObjectForm(request.POST or None, object=instance)	×
261	error = False	×
262	if request.method == 'POST':	×
263	if form.is_valid():	×
264	users_id = form.cleaned_data.get('users')	×
265	role_id = int(form.cleaned_data.get('roles'))	×
266	role = Role.objects.get(id=role_id)	×
267	current_users = instance.get_users_in_role(role.name)	×
268	selected_users = [User.objects.get(id=user_id) for user_id in users_id]	×
269	to_remove = list(set(current_users) - set(selected_users))	×
270	to_add = list(set(selected_users) - set(current_users))	×
271	if instance.spoc in to_remove and role.name == "Admin":	×
272	form.add_error('users', 'SPOC cannot be removed from Admin')	×
273	error = True	×
274	if not error:	×
275	for user in to_add:	×
276	instance.add_user_in_role(user, role.name)	×
277	for user in to_remove:	×
278	instance.remove_user_in_role(user, role.name)	×
279	return redirect(reverse("service_catalog:instance_details", args=[instance_id]) + "#users")	×
280	context = {	×
281	'form': form,
282	'content_type_id': ContentType.objects.get_for_model(Instance).id,
283	'object_id': instance.id,
284	'breadcrumbs': [
285	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
286	{'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
287	{'text': "Users", 'url': ""}
288	]
289	}
290	return render(request, 'profiles/role/user-role-for-object-form.html', context)	×
291
292
293	@login_required	1✔
294	@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))	1✔
295	def user_in_instance_remove(request, instance_id, user_id):	1✔
296	instance = get_object_or_404(Instance, id=instance_id)	×
297	user = User.objects.get(id=user_id)	×
298	if user == instance.spoc:	×
299	return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#users")	×
300	if request.method == 'POST':	×
301	instance.remove_user_in_role(user)	×
302	return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#users")	×
303	args = {	×
304	"instance_id": instance_id,
305	"user_id": user_id
306	}
307	context = {	×
308	'breadcrumbs': [
309	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
310	{'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
311	{'text': "Users", 'url': ""}
312	],
313	'confirm_text': mark_safe(f"Confirm to remove all roles of the user <strong>{user.username}</strong> from "
314	f"{instance}?"),
315	'action_url': reverse('service_catalog:user_in_instance_remove', kwargs=args),
316	'button_text': 'Remove'
317	}
318	return render(request, 'generics/confirm-delete-template.html', context=context)	×
319
320
321	@login_required	1✔
322	@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))	1✔
323	def team_in_instance_update(request, instance_id):	1✔
324	instance = get_object_or_404(Instance, id=instance_id)	×
325	form = TeamRoleForObjectForm(request.POST or None, user=request.user, object=instance)	×
326	if request.method == 'POST':	×
327	if form.is_valid():	×
328	form.save()	×
329	return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#teams")	×
330	context = {	×
331	'form': form,
332	'content_type_id': ContentType.objects.get_for_model(Instance).id,
333	'object_id': instance.id,
334	'breadcrumbs': [
335	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
336	{'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
337	{'text': "Teams", 'url': ""}
338	]
339	}
340	return render(request, 'profiles/role/team-role-for-object-form.html', context)	×
341
342
343	@login_required	1✔
344	@permission_required_or_403('service_catalog.change_instance', (Instance, 'id', 'instance_id'))	1✔
345	def team_in_instance_remove(request, instance_id, team_id):	1✔
346	instance = get_object_or_404(Instance, id=instance_id)	×
347	team = Team.objects.get(id=team_id)	×
348	if request.method == 'POST':	×
349	instance.remove_team_in_role(team)	×
350	return redirect(reverse('service_catalog:instance_details', args=[instance_id]) + "#teams")	×
351	args = {	×
352	"instance_id": instance_id,
353	"team_id": team_id
354	}
355	context = {	×
356	'breadcrumbs': [
357	{'text': 'Instances', 'url': reverse('service_catalog:instance_list')},
358	{'text': instance.name, 'url': reverse('service_catalog:instance_details', args=[instance_id])},
359	{'text': "Teams", 'url': ""}
360	],
361	'confirm_text': mark_safe(f"Confirm to remove all roles of the team <strong>{team.name}</strong> on "
362	f"{instance}?"),
363	'action_url': reverse('service_catalog:team_in_instance_remove', kwargs=args),
364	'button_text': 'Remove'
365	}
366	return render(request, 'generics/confirm-delete-template.html', context=context)	×

HewlettPackard / squest / 1957057914

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous