def get(self, request, **kwargs):
params = request.GET.copy()
params["status"] = params.get("status", FlagStatus.ACTIVE.value)
data = get_flags(request, **params)
user_data, _ = get_gov_user(request, str(request.user.lite_api_user_id))
filters = FiltersBar(
[
TextInput(name="name", title="name"),
Select(name="level", title="level", options=level_options),
TextInput(name="priority", title="priority"),
Select(name="team", title="team", options=get_teams(request, True)),
Checkboxes(
name="status",
options=[Option(FlagStatus.DEACTIVATED.value, flags.FlagsList.SHOW_DEACTIVATED_FLAGS)],
classes=["govuk-checkboxes--small"],
),
]
)
context = {
"data": data,
"user_data": user_data,
"filters": filters,
"can_change_flag_status": Permission.ACTIVATE_FLAGS.value in get_user_permissions(request),
}
return render(request, "flags/index.html", context)
def get(self, request, **kwargs):
data, _ = get_gov_user(request, str(kwargs["pk"]))
request_user, _ = get_gov_user(request,
str(request.user.lite_api_user_id))
super_user = is_super_user(request_user)
can_deactivate = not is_super_user(data)
can_edit_role = data["user"]["id"] != request.user.lite_api_user_id
context = {
"data": data,
"super_user": super_user,
"super_user_role_id": SUPER_USER_ROLE_ID,
"can_deactivate": can_deactivate,
"can_edit_role": can_edit_role,
}
return render(request, "users/profile.html", context)
def get(self, request, **kwargs):
if Permission.MANAGE_FLAGGING_RULES.value not in get_user_permissions(request):
return redirect(reverse_lazy("cases:cases"))
params = {"page": int(request.GET.get("page", 1))}
params = get_params_if_exist(request, ["only_my_team", "level", "include_deactivated"], params)
data, _ = get_flagging_rules(request, convert_dict_to_query_params(params))
filters = FiltersBar(
[
Select(name="level", title=strings.FlaggingRules.List.Filter.Type, options=_levels),
Checkboxes(
name="only_my_team",
options=[Option("true", strings.FlaggingRules.List.Filter.MY_TEAM_ONLY)],
classes=["govuk-checkboxes--small", "govuk-!-margin-top-6"],
),
Checkboxes(
name="include_deactivated",
options=[Option("true", strings.FlaggingRules.List.Filter.INCLUDE_DEACTIVATED)],
classes=["govuk-checkboxes--small", "govuk-!-margin-top-6"],
),
]
)
context = {
"data": data,
"team": get_gov_user(request)[0]["user"]["team"]["id"],
"filters": filters,
}
return render(request, "flags/flagging-rules-list.html", context)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
user, _ = get_gov_user(request, self.object_pk)
self.user = user["user"]
can_edit_role = self.user["id"] != request.user.lite_api_user_id
self.form = edit_user_form(request, self.user, can_edit_role)
self.data = self.user
self.action = put_gov_user
self.success_url = reverse("users:user", kwargs={"pk": self.object_pk})
def init(self, request, **kwargs):
select_team = has_permission(request, Permission.MANAGE_ALL_ROUTING_RULES)
team_id = request.POST.get("team", get_gov_user(request)[0]["user"]["team"]["id"])
self.forms = routing_rule_form_group(
request=request,
additional_rules=request.POST.getlist("additional_rules[]", ()),
team_id=team_id,
select_team=select_team,
)
self.success_url = reverse("routing_rules:list")
self.action = post_routing_rule
def get(self, request, **kwargs):
user, _ = get_gov_user(self.request)
team, _ = get_team(request, str(kwargs["pk"]))
users, _ = get_users_by_team(request, str(kwargs["pk"]))
context = {
"team": team["team"],
"users": users["users"],
"is_user_in_team": user["user"]["team"]["id"] == team["team"]["id"],
"can_manage_picklists": Permission.MANAGE_PICKLISTS.value in get_user_permissions(request),
}
return render(request, "teams/team.html", context)
def get(self, request, **kwargs):
page = request.GET.get("page", 1)
name = request.GET.get("name")
queues = get_queues(request, page=page, disable_pagination=False, name=name)
user_data, _ = get_gov_user(request, str(request.user.lite_api_user_id))
filters = FiltersBar([TextInput(name="name", title="name"),])
context = {
"data": queues,
"user_data": user_data,
"filters": filters,
"name": name,
}
return render(request, "queues/manage.html", context)
def get(self, request, **kwargs):
roles, _ = get_roles(request)
all_permissions = get_permissions(request)
permissions = get_user_permissions(request)
user, _ = get_gov_user(request)
context = {
"all_permissions": all_permissions,
"roles": roles["roles"],
"title": strings.roles.ManageRolesPage.TITLE,
"user_permissions": permissions,
"super_user_role_id": SUPER_USER_ROLE_ID,
"user_role_id": user["user"]["role"]["id"],
}
return render(request, "users/roles.html", context)
def get(self, request, **kwargs):
params = {
"page": int(request.GET.get("page", 1)),
**get_params_if_exist(request, ["case_status", "team", "queue", "tier", "only_active"]),
}
data, _ = get_routing_rules(request, convert_dict_to_query_params(params))
user_data, _ = get_gov_user(request, str(request.user.lite_api_user_id))
status = request.GET.get("status", "active")
filters = FiltersBar(
[
Select(title=Filter.CASE_STATUS, name="case_status", options=get_statuses(request, True)),
*conditional(
has_permission(request, Permission.MANAGE_ALL_ROUTING_RULES),
[
Select(title=Filter.TEAM, name="team", options=get_teams(request, True)),
AutocompleteInput(
title=Filter.QUEUE, name="queue", options=get_queues(request, convert_to_options=True),
),
],
[
AutocompleteInput(
title=Filter.QUEUE,
name="queue",
options=get_users_team_queues(request, request.user.lite_api_user_id, True),
),
],
),
TextInput(title=Filter.TIER, name="tier"),
Checkboxes(
name="only_active", options=[Option(True, Filter.ACTIVE_ONLY)], classes=["govuk-checkboxes--small"],
),
]
)
context = {
"data": data,
"status": status,
"user_data": user_data,
"filters": filters,
}
return render(request, "routing-rules/index.html", context)
def get_permissible_statuses(request, case):
""" Get a list of case statuses permissible for the user's role. """
user, _ = get_gov_user(request, str(request.user.lite_api_user_id))
user_permissible_statuses = user["user"]["role"]["statuses"]
statuses, _ = get_statuses(request)
case_sub_type = case["case_type"]["sub_type"]["key"]
case_type = case["case_type"]["type"]["key"]
if case_type == CaseType.APPLICATION.value:
case_type_applicable_statuses = [
status
for status in statuses
if status["key"]
not in [
CaseStatusEnum.APPLICANT_EDITING,
CaseStatusEnum.CLOSED,
CaseStatusEnum.FINALISED,
CaseStatusEnum.REGISTERED,
CaseStatusEnum.CLC,
CaseStatusEnum.PV,
CaseStatusEnum.SURRENDERED,
]
]
elif case_type == CaseType.QUERY.value:
if case_sub_type == CaseType.END_USER_ADVISORY.value:
case_type_applicable_statuses = [
status for status in statuses if status["key"] in CaseStatusEnum.base_query_statuses()
]
else:
# if the query is not an end user advisory, then check if CLC/PV statuses are required
goods_query_status_keys = CaseStatusEnum.base_query_statuses().copy()
if case.data["clc_responded"] is not None:
goods_query_status_keys.insert(1, CaseStatusEnum.CLC)
if case.data["pv_grading_responded"] is not None:
# add PV status into the correct location
if case.data["clc_responded"] is not None:
goods_query_status_keys.insert(2, CaseStatusEnum.PV)
else:
goods_query_status_keys.insert(1, CaseStatusEnum.PV)
def init(self, request, **kwargs):
self.object_pk = kwargs["pk"]
case_ids = request.GET.getlist("cases")
if not case_ids:
return error_page(request, "Invalid case selection")
queue = get_queue(request, self.object_pk)
case_assignments, _ = get_queue_case_assignments(request, self.object_pk)
assigned_users = [
assignment["user"] for assignment in case_assignments["case_assignments"] if assignment["case"] in case_ids
]
user_data, _ = get_gov_user(request, str(request.user.lite_api_user_id))
self.data = {"users": assigned_users}
self.form = assign_users_form(request, user_data["user"]["team"]["id"], queue, len(case_ids) > 1)
self.action = put_queue_case_assignments
self.success_url = reverse("queues:cases", kwargs={"queue_pk": self.object_pk})
self.success_message = (
Manage.AssignUsers.SUCCESS_MULTI_MESSAGE if len(case_ids) > 1 else Manage.AssignUsers.SUCCESS_MESSAGE
)
def get(self, request, **kwargs):
params = {
"page": int(self.request.GET.get("page", 1)),
"email": self.request.GET.get("email", ""),
"status": self.request.GET.get("status", ""),
}
data, _ = get_gov_users(request, params)
user, _ = get_gov_user(request, str(request.user.lite_api_user_id))
super_user = is_super_user(user)
statuses = [
Option(option["key"], option["value"]) for option in [
{
"key": "active",
"value": UserStatuses.ACTIVE
},
{
"key": "deactivated",
"value": UserStatuses.DEACTIVATED
},
{
"key": "",
"value": "All"
},
]
]
filters = FiltersBar([
Select(name="status", title="status", options=statuses),
TextInput(name="email", title="email"),
])
context = {
"data": data,
"super_user": super_user,
"filters": filters,
}
return render(request, "users/index.html", context)
def get(self, request, **kwargs):
"""
Return a list of picklists and show all the relevant items
"""
picklist_type = request.GET.get(
"type",
PicklistCategories.proviso.key) # Ensure that the page has a type
user, _ = get_gov_user(request)
team, _ = get_team(request, user["user"]["team"]["id"])
picklist_items = get_picklists_list(request,
type=picklist_type,
page=request.GET.get("page", 1),
name=request.GET.get("name"))
active_picklist_items = [
x for x in picklist_items["results"]
if x["status"]["key"] == "active"
]
deactivated_picklist_items = [
x for x in picklist_items["results"]
if x["status"]["key"] != "active"
]
filters = FiltersBar([
HiddenField(name="type", value=picklist_type),
TextInput(name="name", title="name")
])
context = {
"team": team["team"],
"active_picklist_items": active_picklist_items,
"deactivated_picklist_items": deactivated_picklist_items,
"data": picklist_items,
"type": picklist_type,
"filters": filters,
"name": request.GET.get("name"),
"picklist_categories": PicklistCategories.all(),
}
return render(request, "teams/picklists.html", context)
def _get_team_flags(level,
request,
convert_to_options=False,
include_deactivated=False):
user, _ = get_gov_user(request)
team_pk = user["user"]["team"]["id"]
data = get(
request,
f"{FLAGS_URL}?level={level}&team={team_pk}&include_deactivated={include_deactivated}&disable_pagination=True",
).json()
if convert_to_options:
return [
Option(
key=flag["id"],
value=flag["name"],
classes=[
"app-flag", "app-flag--checkbox",
"app-flag--" + flag["colour"]
],
) for flag in data
]
return data
def get_user_permissions(request, with_team=False):
user, _ = get_gov_user(request)
if with_team:
return user["user"]["role"]["permissions"], user["user"]["team"]
return user["user"]["role"]["permissions"]
def get_redirect_url(self):
user, _ = get_gov_user(self.request)
return reverse_lazy("teams:team", kwargs={"pk": user["user"]["team"]["id"]})
