def edit_user_form(request, user, can_edit_role: bool):
return Form(
title=EditUserForm.TITLE.format(user["first_name"], user["last_name"]),
questions=[
TextInput(title=EditUserForm.Email.TITLE, description=EditUserForm.Email.DESCRIPTION, name="email"),
Select(
title=EditUserForm.Team.TITLE,
description=EditUserForm.Team.DESCRIPTION,
name="team",
options=get_teams(request, True),
),
conditional(
can_edit_role,
Select(
title=EditUserForm.Role.TITLE,
description=EditUserForm.Role.DESCRIPTION,
name="role",
options=get_roles(request, True),
),
),
Select(
title=EditUserForm.DefaultQueue.TITLE,
description=EditUserForm.DefaultQueue.DESCRIPTION,
name="default_queue",
options=get_queues(request, include_system=True, convert_to_options=True),
),
],
back_link=BackLink(
EditUserForm.BACK_LINK.format(user["first_name"], user["last_name"]),
reverse_lazy("users:user", kwargs={"pk": user["id"]}),
),
default_button_name=EditUserForm.SUBMIT_BUTTON,
javascript_imports={"/javascripts/filter-default-queue-list.js"},
)
def get_open_general_licences(self):
params = self.request.GET.copy()
params.pop("licence_type")
self.data = get_open_general_licences(self.request, registered=True, **params)
control_list_entries = get_potential_ogl_control_list_entries(self.data)
countries = get_potential_ogl_countries(self.data)
sites = get_potential_ogl_sites(self.data)
self.filters = [
TextInput(name="name", title=OpenGeneralLicencesList.Filters.NAME),
Select(
name="case_type",
title=OpenGeneralLicencesList.Filters.TYPE,
options=OpenGeneralExportLicenceTypes.as_options(),
),
AutocompleteInput(
name="control_list_entry",
title=OpenGeneralLicencesList.Filters.CONTROL_LIST_ENTRY,
options=control_list_entries,
),
AutocompleteInput(name="country", title=OpenGeneralLicencesList.Filters.COUNTRY, options=countries),
Select(name="site", title=OpenGeneralLicencesList.Filters.SITE, options=sites,),
Checkboxes(
name="active_only",
options=[Option(key=True, value=OpenGeneralLicencesList.Filters.ONLY_SHOW_ACTIVE)],
classes=["govuk-checkboxes--small"],
),
]
self.template = "open-general-licences"
def add_user_form(request):
return Form(
title=AddUserForm.TITLE,
questions=[
TextInput(title=AddUserForm.Email.TITLE, description=AddUserForm.Email.DESCRIPTION, name="email"),
Select(
title=AddUserForm.Team.TITLE,
description=AddUserForm.Team.DESCRIPTION,
name="team",
options=get_teams(request, True),
),
Select(
title=AddUserForm.Role.TITLE,
description=AddUserForm.Role.DESCRIPTION,
name="role",
options=get_roles(request, True),
),
Select(
title=AddUserForm.DefaultQueue.TITLE,
description=AddUserForm.DefaultQueue.DESCRIPTION,
name="default_queue",
options=get_queues(request, include_system=True, convert_to_options=True),
),
],
back_link=BackLink(AddUserForm.BACK_LINK, reverse_lazy("users:users")),
javascript_imports={"/javascripts/filter-default-queue-list.js"},
)
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 generate_activity_filters(activity_filters, string_class):
def make_options(values):
return [Option(option["key"], option["value"]) for option in values]
return FiltersBar(
[
Select(
title=string_class.ActivityFilters.USER,
name="user_id",
options=make_options(activity_filters["users"]),
),
Select(
title=string_class.ActivityFilters.TEAM,
name="team_id",
options=make_options(activity_filters["teams"]),
),
Select(
title=string_class.ActivityFilters.USER_TYPE,
name="user_type",
options=make_options(activity_filters["user_types"]),
),
Select(
title=string_class.ActivityFilters.ACTIVITY_TYPE,
name="activity_type",
options=make_options(activity_filters["activity_types"]),
),
DateInput(title=string_class.ActivityFilters.DATE_FROM, prefix="from_", inline_title=True),
DateInput(title=string_class.ActivityFilters.DATE_TO, prefix="to_", inline_title=True),
]
)
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.session["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.session["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_additional_context(self):
status = self.request.GET.get("status")
params = {"page": int(self.request.GET.get("page", 1))}
if status:
params["status"] = status
users = get_organisation_users(
self.request, str(self.request.session["organisation"]), params)
statuses = [
Option(option["key"], option["value"]) for option in [
{
"key": "active",
"value": "Active"
},
{
"key": "deactivated",
"value": "Deactivated"
},
{
"key": "",
"value": "All"
},
]
]
filters = FiltersBar(
[Select(name="status", title="status", options=statuses)])
return {
"status": status,
"data": users,
"page": params.pop("page"),
"params_str": convert_dict_to_query_params(params),
"filters": filters,
}
def initial_routing_rule_questions(request, team_id, is_editing: bool):
if is_editing:
title = Forms.EDIT_TITLE
else:
title = Forms.CREATE_TITLE
return Form(
title=title,
questions=[
Select(title=Forms.CASE_STATUS,
name="status",
options=get_statuses(request, True)),
AutocompleteInput(
title=Forms.QUEUE,
name="queue",
options=get_team_queues(request, team_id, True, True),
),
TextInput(title=Forms.TIER, name="tier"),
HiddenField(name="additional_rules[]", value=None),
Checkboxes(
title=Forms.ADDITIONAL_RULES,
name="additional_rules[]",
options=additional_rules,
),
],
back_link=BackLink(Forms.BACK_BUTTON,
reverse_lazy("routing_rules:list")),
)
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 edit_queue_form(request, queue_id):
return Form(
title=EditQueueForm.TITLE,
description=EditQueueForm.DESCRIPTION,
questions=[
TextInput(
title=EditQueueForm.Name.TITLE,
description=EditQueueForm.Name.DESCRIPTION,
name="name",
),
Select(
title=EditQueueForm.CountersigningQueue.TITLE,
description=EditQueueForm.CountersigningQueue.DESCRIPTION,
options=remove_current_queue_id(
get_queues(request=request,
disable_pagination=True,
convert_to_options=True,
users_team_first=True),
queue_id,
),
name="countersigning_queue",
),
],
back_link=BackLink(EditQueueForm.BACK, reverse_lazy("queues:manage")),
)
def pv_details_form(request):
return Form(
title=GoodGradingForm.TITLE,
description=GoodGradingForm.DESCRIPTION,
questions=[
Heading("PV grading", HeadingStyle.M),
Group(
components=[
TextInput(title=GoodGradingForm.PREFIX, name="prefix", optional=True),
Select(
options=get_pv_gradings(request, convert_to_options=True),
title=GoodGradingForm.GRADING,
name="grading",
optional=True,
),
TextInput(title=GoodGradingForm.SUFFIX, name="suffix", optional=True),
],
classes=["app-pv-grading-inputs"],
),
TextInput(title=GoodGradingForm.OTHER_GRADING, name="custom_grading", optional=True),
TextInput(title=GoodGradingForm.ISSUING_AUTHORITY, name="issuing_authority"),
TextInput(title=GoodGradingForm.REFERENCE, name="reference"),
DateInput(
title=GoodGradingForm.DATE_OF_ISSUE, prefix="date_of_issue", name="date_of_issue", optional=False
),
],
default_button_name=GoodGradingForm.BUTTON,
)
def document_grading_form(request, good_id):
select_options = get_document_missing_reasons(request)[0]["reasons"]
return Form(
title=DocumentSensitivityForm.TITLE,
description=DocumentSensitivityForm.DESCRIPTION,
questions=[
RadioButtons(
name="has_document_to_upload",
options=[
Option(key="yes", value=DocumentSensitivityForm.Options.YES),
Option(
key="no",
value=DocumentSensitivityForm.Options.NO,
components=[
Label(text=DocumentSensitivityForm.ECJU_HELPLINE),
Select(
name="missing_document_reason",
title=DocumentSensitivityForm.LABEL,
options=select_options,
),
],
),
],
),
],
back_link=BackLink(DocumentSensitivityForm.BACK_BUTTON, reverse_lazy("goods:good", kwargs={"pk": good_id})),
default_button_name=DocumentSensitivityForm.SUBMIT_BUTTON,
)
def get(self, request, *args, **kwargs):
open_general_licences = get_open_general_licences(
request, **request.GET)
control_list_entries = get_control_list_entries(request, True)
countries = get_countries(request, True)
filters = FiltersBar([
HiddenField("status", request.GET.get("status", "active")),
TextInput(name="name", title="name"),
Select(name="case_type",
title="type",
options=OpenGeneralExportLicences.as_options()),
AutocompleteInput(name="control_list_entry",
title="control list entry",
options=control_list_entries),
AutocompleteInput(name="country",
title="country",
options=countries),
])
context = {
"filters": filters,
"tab": request.GET.get("status", "active"),
"open_general_licences": open_general_licences,
}
return render(request, "open-general-licences/index.html", context)
def select_condition_and_flag(request, type: str):
title = ""
condition = []
flags = []
is_for_verified_goods_only = None
if type == "Good":
title = strings.FlaggingRules.Create.Condition_and_flag.GOOD_TITLE
condition = TextInput(title=strings.FlaggingRules.Create.Condition_and_flag.GOOD, name="matching_value",)
flags = get_goods_flags(request=request)
is_for_verified_goods_only = RadioButtons(
name="is_for_verified_goods_only",
options=[
Option(key=True, value=FlaggingRules.Create.Condition_and_flag.YES_OPTION),
Option(key=False, value=FlaggingRules.Create.Condition_and_flag.NO_OPTION),
],
title=FlaggingRules.Create.Condition_and_flag.GOODS_QUESTION,
)
elif type == "Destination":
title = strings.FlaggingRules.Create.Condition_and_flag.DESTINATION_TITLE
condition = AutocompleteInput(
title=strings.FlaggingRules.Create.Condition_and_flag.DESTINATION,
name="matching_value",
options=get_countries(request, convert_to_options=True),
)
flags = get_destination_flags(request=request)
elif type == "Case":
title = strings.FlaggingRules.Create.Condition_and_flag.APPLICATION_TITLE
case_type_options = [Option(option["key"], option["value"]) for option in get_case_types(request)]
condition = Select(
title=strings.FlaggingRules.Create.Condition_and_flag.APPLICATION,
name="matching_value",
options=case_type_options,
)
flags = get_cases_flags(request=request)
return Form(
title=title,
questions=[
condition,
Select(title=strings.FlaggingRules.Create.Condition_and_flag.FLAG, name="flag", options=flags),
is_for_verified_goods_only,
],
)
def unit_quantity_value(request, good, sub_case_type, application_id):
if sub_case_type["key"] == EXHIBITION:
return exhibition_item_type(request, good.get("id"), application_id)
else:
questions = [
good_summary(good),
HiddenField(name="good_id", value=good.get("id")),
Select(
title=AddGoodToApplicationForm.Units.TITLE,
description="<noscript>" +
AddGoodToApplicationForm.Units.DESCRIPTION + "</noscript>",
name="unit",
options=get_units(request),
),
QuantityInput(
title=AddGoodToApplicationForm.Quantity.TITLE,
description=AddGoodToApplicationForm.Quantity.DESCRIPTION,
name="quantity",
),
CurrencyInput(
title=AddGoodToApplicationForm.VALUE.TITLE,
description=AddGoodToApplicationForm.VALUE.DESCRIPTION,
name="value",
),
RadioButtons(
name="is_good_incorporated",
title=AddGoodToApplicationForm.Incorporated.TITLE,
description=AddGoodToApplicationForm.Incorporated.DESCRIPTION,
options=[
Option(True, AddGoodToApplicationForm.Incorporated.YES),
Option(False, AddGoodToApplicationForm.Incorporated.NO),
],
classes=["govuk-radios--inline"],
),
]
if good["item_category"]["key"] == PRODUCT_CATEGORY_FIREARM:
firearm_type = good["firearm_details"]["type"]["key"]
if firearm_type in ["ammunition", "firearms"]:
questions.append(firearm_proof_mark_field())
elif firearm_type == "components_for_firearms":
questions.append(
does_firearm_component_require_proof_marks_field())
questions.append(firearm_is_deactivated_field())
return Form(
title=AddGoodToApplicationForm.TITLE,
description=AddGoodToApplicationForm.DESCRIPTION,
questions=questions,
back_link=BackLink(
strings.BACK_TO_APPLICATION,
reverse_lazy("applications:preexisting_good",
kwargs={"pk": application_id}),
),
javascript_imports={"/javascripts/add-good.js"},
)
def visit_report_form(queue_pk, pk):
return Form(
title=ComplianceForms.VisitReport.TITLE,
questions=[
Select(title=ComplianceForms.VisitReport.VISIT_TYPE, name="visit_type", options=Visit_type_choices),
DateInput(
title=ComplianceForms.VisitReport.VISIT_DATE,
description=ComplianceForms.VisitReport.VISIT_DATE_DESCRIPTION,
name="visit_date",
prefix="visit_date_",
),
Select(title=ComplianceForms.VisitReport.OVERALL_RISK_VALUE, name="overall_risk_value", options=risk_value),
Select(
title=ComplianceForms.VisitReport.LICENCE_RISK_VALUE,
name="licence_risk_value",
options=licence_risk_value,
),
],
back_link=BackLink(url=reverse("cases:case", kwargs={"queue_pk": queue_pk, "pk": pk, "tab": "details"})),
)
def firearm_is_deactivated_field():
return RadioButtons(
title="Has the product been deactivated?",
name="is_deactivated",
options=[
Option(
key=True,
value="Yes",
components=[
DateInput(
title="Date of deactivation",
name="date_of_deactivation",
prefix="date_of_deactivation",
),
RadioButtons(
title=
"Has the product been deactivated to UK/EU proof house standards?",
name="is_deactivated_to_standard",
options=[
Option(
key=True,
value="Yes",
components=[
Select(
title="Proof house standard",
name="deactivation_standard",
options=[
Option(key="UK", value="UK"),
Option(key="EU", value="EU"),
],
),
],
),
Option(
key=False,
value="No",
components=[
TextArea(
title=
"Describe who deactivated the product and to what standard it was done",
description="",
name="deactivation_standard_other",
optional=False,
),
],
),
],
),
],
),
Option(key=False, value="No"),
],
)
def knowledge_of_products_form(queue_pk, pk):
return Form(
title=ComplianceForms.KnowledgeOfProducts.TITLE,
questions=[
TextArea(
title=ComplianceForms.KnowledgeOfProducts.OVERVIEW, name="products_overview", extras={"max_length": 750}
),
Select(
title=ComplianceForms.KnowledgeOfProducts.RISK_VALUE, name="products_risk_value", options=risk_value
),
],
back_link=BackLink(url=reverse("cases:case", kwargs={"queue_pk": queue_pk, "pk": pk, "tab": "details"})),
)
def get(self, request, **kwargs):
search_term = request.GET.get("search_term", "").strip()
org_type = request.GET.get("org_type", "").strip()
params = {
"page": int(request.GET.get("page", 1)),
"status": request.GET.get("status", "active")
}
if search_term:
params["search_term"] = search_term
if org_type:
params["org_type"] = org_type
organisations, _ = get_organisations(
request, convert_dict_to_query_params(params))
filters = FiltersBar([
TextInput(name="search_term",
title=OrganisationsPage.Filters.NAME),
Select(
name="org_type",
title=OrganisationsPage.Filters.TYPE,
options=[
Option("individual",
OrganisationsPage.Filters.Types.INDIVIDUAL),
Option("commercial",
OrganisationsPage.Filters.Types.COMMERCIAL),
Option("hmrc", OrganisationsPage.Filters.Types.HMRC),
],
),
HiddenField(name="status", value=params["status"]),
])
context = {
"data":
organisations,
"filters":
filters,
"search_term":
params.get("search_term", ""),
"tab":
params.get("status"),
"in_review_total":
get_menu_notifications(request)["notifications"].get(
"organisations"),
"can_manage_organisations":
Permission.MANAGE_ORGANISATIONS.value
in get_user_permissions(request),
}
return render(request, "organisations/index.html", context)
def good_on_application_form(request, good, sub_case_type, application_id):
if sub_case_type["key"] == EXHIBITION:
return exhibition_good_on_application_form(request, good.get("id"),
application_id)
else:
return Form(
title=AddGoodToApplicationForm.TITLE,
description=AddGoodToApplicationForm.DESCRIPTION,
questions=[
good_summary(good),
HiddenField(name="good_id", value=good.get("id")),
Select(
title=AddGoodToApplicationForm.Units.TITLE,
description="<noscript>" +
AddGoodToApplicationForm.Units.DESCRIPTION + "</noscript>",
name="unit",
options=get_units(request),
),
QuantityInput(
title=AddGoodToApplicationForm.Quantity.TITLE,
description=AddGoodToApplicationForm.Quantity.DESCRIPTION,
name="quantity",
),
CurrencyInput(
title=AddGoodToApplicationForm.VALUE.TITLE,
description=AddGoodToApplicationForm.VALUE.DESCRIPTION,
name="value",
),
RadioButtons(
name="is_good_incorporated",
title=AddGoodToApplicationForm.Incorporated.TITLE,
description=AddGoodToApplicationForm.Incorporated.
DESCRIPTION,
options=[
Option(True,
AddGoodToApplicationForm.Incorporated.YES),
Option(False,
AddGoodToApplicationForm.Incorporated.NO),
],
classes=["govuk-radios--inline"],
),
],
back_link=BackLink(
strings.BACK_TO_APPLICATION,
reverse_lazy("applications:preexisting_good",
kwargs={"pk": application_id}),
),
javascript_imports={"/javascripts/add-good.js"},
)
def add_flag_form():
return Form(
title=CreateFlagForm.TITLE,
description=CreateFlagForm.DESCRIPTION,
questions=[
TextInput(title=CreateFlagForm.Name.TITLE, description=CreateFlagForm.Name.DESCRIPTION, name="name"),
Select(
title=CreateFlagForm.Level.TITLE,
description=CreateFlagForm.Level.DESCRIPTION,
name="level",
options=level_options,
),
RadioButtons(
title=CreateFlagForm.Colour.TITLE,
description=CreateFlagForm.Colour.DESCRIPTION,
name="colour",
classes=["app-radios--flag-colours"],
options=[
Option("default", "Default"),
Option("red", "Red", classes=["app-radios__item--red"]),
Option("yellow", "Yellow", classes=["app-radios__item--yellow"]),
Option("green", "Green", classes=["app-radios__item--green"]),
Option("blue", "Blue", classes=["app-radios__item--blue"]),
Option("purple", "Purple", classes=["app-radios__item--purple"]),
Option("orange", "Orange", classes=["app-radios__item--orange"]),
Option("brown", "Brown", classes=["app-radios__item--brown"]),
Option("turquoise", "Turquoise", classes=["app-radios__item--turquoise"]),
Option("pink", "Pink", classes=["app-radios__item--pink"]),
],
),
TextInput(name="label", title=CreateFlagForm.Label.TITLE, description=CreateFlagForm.Label.DESCRIPTION,),
NumberInput(
name="priority", title=CreateFlagForm.Priority.TITLE, description=CreateFlagForm.Priority.DESCRIPTION
),
RadioButtons(
name="blocks_approval",
title=CreateFlagForm.BlocksApproval.TITLE,
options=[
Option(True, CreateFlagForm.BlocksApproval.YES),
Option(False, CreateFlagForm.BlocksApproval.NO),
],
classes=["govuk-radios--inline"],
),
],
default_button_name=CreateFlagForm.SUBMIT_BUTTON,
back_link=BackLink(CreateFlagForm.BACK_LINK, reverse_lazy("flags:flags")),
javascript_imports={"/javascripts/add-edit-flags.js"},
)
def compliance_with_licence_form(queue_pk, pk):
return Form(
title=ComplianceForms.ComplianceWithLicence.TITLE,
description=ComplianceForms.ComplianceWithLicence.DESCRIPTION,
questions=[
TextArea(
title=ComplianceForms.ComplianceWithLicence.OVERVIEW,
name="compliance_overview",
extras={"max_length": 750},
),
Select(
title=ComplianceForms.ComplianceWithLicence.RISK_VALUE, name="compliance_risk_value", options=risk_value
),
],
back_link=BackLink(url=reverse("cases:case", kwargs={"queue_pk": queue_pk, "pk": pk, "tab": "details"})),
)
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.session["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 edit_user_form(request, user_id, can_edit_role: bool):
return Form(
title=strings.users.EditUserForm.USER_EDIT_TITLE,
questions=[
conditional(
can_edit_role,
Select(
name="role",
options=get_roles(request, request.user.organisation,
True),
title=strings.users.EditUserForm.USER_ROLE_QUESTION,
include_default_select=False,
),
),
],
back_link=BackLink(
strings.users.EditUserForm.USER_EDIT_FORM_BACK_TO_USER,
reverse_lazy("organisation:members:user", kwargs={"pk": user_id}),
),
default_button_name=strings.users.EditUserForm.USER_EDIT_FORM_SAVE,
)
def initial_routing_rule_questions(request, select_team, team_id,
is_editing: bool):
team_queues_options = get_team_queues(request,
team_id,
convert_to_options=True,
ignore_pagination=True)
return Form(
title=Forms.EDIT_TITLE if is_editing else Forms.CREATE_TITLE,
questions=[
AutocompleteInput(
title=Forms.TEAM,
name="team",
options=get_teams(request, True),
description="Type to get suggestions. For example, TAU.",
),
Select(title=Forms.CASE_STATUS,
name="status",
options=get_statuses(request, True)),
AutocompleteInput(
title=Forms.QUEUE,
name="queue",
options=team_queues_options,
description=
"Type to get suggestions.\nFor example, HMRC enquiries.",
),
TextInput(title=Forms.TIER, name="tier"),
HiddenField(name="additional_rules[]", value=None),
Checkboxes(
title=Forms.ADDITIONAL_RULES,
name="additional_rules[]",
options=additional_rules,
),
],
back_link=BackLink(Forms.BACK_BUTTON,
reverse_lazy("routing_rules:list")),
javascript_imports={"/javascripts/routing-rules-teams.js"},
)
def add_user_form(request):
return Form(
title=strings.users.AddUserForm.USER_ADD_TITLE,
questions=[
TextInput(title=strings.users.AddUserForm.USER_EMAIL_QUESTION,
name="email"),
Select(
name="role",
options=get_roles(request, request.user.organisation, True),
title=strings.users.AddUserForm.USER_ROLE_QUESTION,
include_default_select=False,
),
Checkboxes(
title=strings.users.AddUserForm.ASSIGN_USER_QUESTION,
name="sites[]",
options=get_sites(request, request.user.organisation, True),
),
],
back_link=BackLink(
strings.users.AddUserForm.USER_ADD_FORM_BACK_TO_USERS,
reverse_lazy("organisation:members:members")),
)
def initial_routing_rule_questions(request, select_team, team_id,
is_editing: bool):
select_team_question = []
if select_team:
select_team_question = [
AutocompleteInput(
title=Forms.TEAM,
name="team",
options=get_teams(request, True),
description="Type to get suggestions. For example, TAU.",
),
]
return Form(
title=Forms.EDIT_TITLE if is_editing else Forms.CREATE_TITLE,
questions=select_team_question + [
Select(title=Forms.CASE_STATUS,
name="status",
options=get_statuses(request, True)),
AutocompleteInput(
title=Forms.QUEUE,
name="queue",
options=get_team_queues(request, team_id, True, True)
if team_id else [],
description=
"Type to get suggestions.\nFor example, HMRC enquiries.",
),
TextInput(title=Forms.TIER, name="tier"),
HiddenField(name="additional_rules[]", value=None),
Checkboxes(
title=Forms.ADDITIONAL_RULES,
name="additional_rules[]",
options=additional_rules,
),
],
back_link=BackLink(Forms.BACK_BUTTON,
reverse_lazy("routing_rules:list")),
)
def open_licence_return_form_group():
return FormGroup([
Form(
title=OpenReturnsHelpPage.TITLE,
questions=[
Label(OpenReturnsHelpPage.DESCRIPTION),
DetailComponent(OpenReturnsHelpPage.FORMATTING_HELP_LINK,
OpenReturnsHelpPage.FORMATTING_HELP_DETAILS),
],
default_button_name=OpenReturnsHelpPage.BUTTON,
back_link=BackLink(OpenReturnsHelpPage.BACK,
reverse_lazy("core:home")),
),
Form(
title=OpenReturnsForm.Year.TITLE,
description=OpenReturnsForm.Year.DESCRIPTION,
questions=[
Select(
title=OpenReturnsForm.Year.FIELD_TITLE,
description=OpenReturnsForm.Year.FIELD_DESCRIPTION,
name="year",
options=get_years(),
)
],
default_button_name=OpenReturnsForm.Year.BUTTON,
),
Form(
title=OpenReturnsForm.Upload.TITLE,
description=OpenReturnsForm.Upload.DESCRIPTION,
questions=[
FileUpload(),
Label(OpenReturnsForm.Upload.ExampleTable.HEADING),
Custom("components/spreadsheet.html"),
],
default_button_name=OpenReturnsForm.Upload.BUTTON,
),
])
name="type",
description="<noscript>" +
advice.GiveOrChangeAdvicePage.RadioButtons.DESCRIPTION +
"</noscript>",
options=[
Option(
key="approve",
value=advice.GiveOrChangeAdvicePage.RadioButtons.GRANT,
components=[
conditional(
CaseType.is_mod(
case["case_type"]["sub_type"]["key"]),
Select(
name="pv_grading_approve",
title=advice.GiveOrChangeAdvicePage.
GRADING_TITLE,
options=get_pv_gradings(
request, convert_to_options=True),
),
)
],
),
Option(
key="proviso",
value=advice.GiveOrChangeAdvicePage.RadioButtons.
PROVISO,
components=[
conditional(
CaseType.is_mod(
case["case_type"]["sub_type"]["key"]),
Select(
def select_condition_and_flag(request, type: str):
flags = []
is_for_verified_goods_only = None
if type == "Good":
flags = get_goods_flags(request=request)
is_for_verified_goods_only = RadioButtons(
name="is_for_verified_goods_only",
options=[
Option(key=True, value=FlaggingRules.Create.Condition_and_flag.YES_OPTION),
Option(key=False, value=FlaggingRules.Create.Condition_and_flag.NO_OPTION),
],
title=FlaggingRules.Create.Condition_and_flag.GOODS_QUESTION,
)
entries = get_control_list_entries(request)
clc_groups, clc_nodes = get_clc_entry_groups_and_nodes(entries)
# if the child node has children of its own then that needs to selectable as
# both individual entry as well as group entry because of this duplicates are
# possible in the combined list hence remove them. We need groups at the top
# because autocomplete only shows first 10 entries which makes it difficult to
# select certain groups otherwise. eg ML10b1 comes before ML1
combined_entries = list(clc_groups)
rating_seen = set([item["rating"] for item in combined_entries])
for item in clc_nodes:
if item["rating"] not in rating_seen:
rating_seen.add(item["rating"])
combined_entries.append(item)
clc_nodes_options = [
Option(key=item["rating"], value=item["rating"], description=item["text"],) for item in clc_nodes
]
clc_groups_options = [
Option(key=item["rating"], value=item["rating"], description=item["text"],) for item in clc_groups
]
clc_combined_options = [
Option(key=item["rating"], value=item["rating"], description=item["text"],) for item in combined_entries
]
return Form(
title="Set flagging rules",
questions=[
Heading("Add a condition", HeadingStyle.S),
TokenBar(
title="Select individual control list entries",
name="matching_values",
description="Type to get suggestions. For example, ML1a.",
options=clc_nodes_options,
),
TokenBar(
title="Select a control list entry group",
name="matching_groups",
description="Type to get suggestions. For example, ML8.\nThis will add every control list entry under ML8.",
options=clc_groups_options,
),
TokenBar(
title="Excluded control list entries",
name="excluded_values",
description="Type to get suggestions. For example, ML1a, ML8.\nThis will exclude ML1a and every control list entry under ML8.",
options=clc_combined_options,
),
Heading("Set an action", HeadingStyle.S),
Select(title=strings.FlaggingRules.Create.Condition_and_flag.FLAG, name="flag", options=flags),
is_for_verified_goods_only,
],
default_button_name="Create flagging rule",
)
elif type == "Destination":
flags = get_destination_flags(request=request)
return Form(
title="Set flagging rules",
questions=[
Heading("Add a condition", HeadingStyle.S),
TokenBar(
title="Select destinations",
name="matching_values",
description="Type to get suggestions. For example, Australia",
options=get_countries(request, convert_to_options=True),
),
Heading("Add an action", HeadingStyle.S),
Select(title=strings.FlaggingRules.Create.Condition_and_flag.FLAG, name="flag", options=flags),
],
default_button_name="Create flagging rule",
)
elif type == "Case":
case_type_options = [Option(option["key"], option["value"]) for option in get_case_types(request)]
flags = get_cases_flags(request=request)
return Form(
title="Set flagging rules",
questions=[
Heading("Add a condition", HeadingStyle.S),
TokenBar(
title="Select application type",
name="matching_values",
description="Type to get suggestions.\nFor example, Standard Individual Export Licence",
options=case_type_options,
),
Heading("Add an action", HeadingStyle.S),
Select(title=strings.FlaggingRules.Create.Condition_and_flag.FLAG, name="flag", options=flags),
],
default_button_name="Create flagging rule",
)
