blob: ae607f2b1740dc19d2fe0e595721b142a3ba5ae9 [file] [log] [blame]
# Copyright 2016 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""A servlet for project and component owners to view and edit field defs."""
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import time
import re
import ezt
from framework import framework_helpers
from framework import framework_views
from framework import permissions
from framework import servlet
from framework import urls
from mrproto import tracker_pb2
from tracker import field_helpers
from tracker import tracker_bizobj
from tracker import tracker_helpers
from tracker import tracker_views
class FieldDetail(servlet.Servlet):
"""Servlet allowing project owners to view and edit a custom field."""
_MAIN_TAB_MODE = servlet.Servlet.MAIN_TAB_PROCESS
_PAGE_TEMPLATE = 'tracker/field-detail-page.ezt'
def _GetFieldDef(self, mr):
"""Get the config and field definition to be viewed or edited."""
# TODO(jrobbins): since so many requests get the config object, and
# it is usually cached in RAM, just always get it and include it
# in the MonorailRequest, mr.
config = self.services.config.GetProjectConfig(
mr.cnxn, mr.project_id, use_cache=False)
field_def = tracker_bizobj.FindFieldDef(mr.field_name, config)
if not field_def:
self.abort(404, 'custom field not found')
return config, field_def
def AssertBasePermission(self, mr):
"""Check whether the user has any permission to visit this page.
Args:
mr: commonly used info parsed from the request.
"""
super(FieldDetail, self).AssertBasePermission(mr)
_config, field_def = self._GetFieldDef(mr)
allow_view = permissions.CanViewFieldDef(
mr.auth.effective_ids, mr.perms, mr.project, field_def)
if not allow_view:
raise permissions.PermissionException(
'User is not allowed to view this field definition')
def GatherPageData(self, mr):
"""Build up a dictionary of data values to use when rendering the page.
Args:
mr: commonly used info parsed from the request.
Returns:
Dict of values used by EZT for rendering the page.
"""
config, field_def = self._GetFieldDef(mr)
approval_def, subfields = None, []
if field_def.field_type == tracker_pb2.FieldTypes.APPROVAL_TYPE:
approval_def = tracker_bizobj.FindApprovalDefByID(
field_def.field_id, config)
user_views = framework_views.MakeAllUserViews(
mr.cnxn, self.services.user, field_def.admin_ids,
approval_def.approver_ids)
subfields = tracker_bizobj.FindApprovalsSubfields(
[field_def.field_id], config)[field_def.field_id]
else:
user_views = framework_views.MakeAllUserViews(
mr.cnxn, self.services.user, field_def.admin_ids,
field_def.editor_ids)
field_def_view = tracker_views.FieldDefView(
field_def, config, user_views=user_views, approval_def=approval_def)
well_known_issue_types = tracker_helpers.FilterIssueTypes(config)
allow_edit = permissions.CanEditFieldDef(
mr.auth.effective_ids, mr.perms, mr.project, field_def)
# Right now we do not allow renaming of enum fields.
_uneditable_name = field_def.field_type == tracker_pb2.FieldTypes.ENUM_TYPE
initial_choices = '\n'.join(
[choice.name if not choice.docstring else (
choice.name + ' = ' + choice.docstring) for
choice in field_def_view.choices])
initial_approvers = ', '.join(sorted([
approver_view.email for approver_view in field_def_view.approvers]))
initial_admins = ', '.join(sorted([
uv.email for uv in field_def_view.admins]))
initial_editors = ', '.join(
sorted([uv.email for uv in field_def_view.editors]))
return {
'admin_tab_mode': servlet.Servlet.PROCESS_TAB_LABELS,
'field_def': field_def_view,
'allow_edit': ezt.boolean(allow_edit),
# TODO(jojwang): update when name changes are actually saved
'uneditable_name': ezt.boolean(True),
'initial_admins': initial_admins,
'initial_editors': initial_editors,
'initial_applicable_type': field_def.applicable_type,
'initial_applicable_predicate': field_def.applicable_predicate,
'initial_approvers': initial_approvers,
'initial_choices': initial_choices,
'approval_subfields': [fd for fd in subfields if not fd.is_deleted],
'well_known_issue_types': well_known_issue_types,
}
def ProcessFormData(self, mr, post_data):
"""Validate and store the contents of the issues tracker admin page.
Args:
mr: commonly used info parsed from the request.
post_data: HTML form data from the request.
Returns:
String URL to redirect the user to, or None if response was already sent.
"""
config, field_def = self._GetFieldDef(mr)
allow_edit = permissions.CanEditFieldDef(
mr.auth.effective_ids, mr.perms, mr.project, field_def)
if not allow_edit:
raise permissions.PermissionException(
'User is not allowed to delete this field')
if 'deletefield' in post_data:
return self._ProcessDeleteField(mr, config, field_def)
elif 'cancel' in post_data:
return framework_helpers.FormatAbsoluteURL(
mr, urls.ADMIN_LABELS, ts=int(time.time()))
else:
return self._ProcessEditField(mr, post_data, config, field_def)
def _ProcessDeleteField(self, mr, config, field_def):
"""The user wants to delete the specified custom field definition."""
field_ids = [field_def.field_id]
if field_def.field_type is tracker_pb2.FieldTypes.APPROVAL_TYPE:
for fd in config.field_defs:
if fd.approval_id == field_def.field_id:
field_ids.append(fd.field_id)
self.services.config.SoftDeleteFieldDefs(
mr.cnxn, mr.project_id, field_ids)
return framework_helpers.FormatAbsoluteURL(
mr, urls.ADMIN_LABELS, deleted=1, ts=int(time.time()))
# TODO(jrobbins): add logic to reaper cron task to look for
# soft deleted field definitions that have no issues with
# any value and hard deleted them.
def _ProcessEditField(self, mr, post_data, config, field_def):
"""The user wants to edit this field definition."""
# TODO(jrobbins): future feature: editable field names
parsed = field_helpers.ParseFieldDefRequest(post_data, config)
admin_ids, admin_str = tracker_helpers.ParsePostDataUsers(
mr.cnxn, post_data['admin_names'], self.services.user)
editor_ids, editor_str = tracker_helpers.ParsePostDataUsers(
mr.cnxn, post_data.get('editor_names', ''), self.services.user)
field_helpers.ParsedFieldDefAssertions(mr, parsed)
if not parsed.is_restricted_field:
assert not editor_ids, 'Editors are only for restricted fields.'
if field_def.field_type == tracker_pb2.FieldTypes.APPROVAL_TYPE:
assert not (
parsed.is_restricted_field), 'Approval fields cannot be restricted.'
assert not editor_ids, 'Approval fields cannot have editors.'
if parsed.approvers_str:
approver_ids_dict = self.services.user.LookupUserIDs(
mr.cnxn,
re.split(r'[,;\s]+', parsed.approvers_str),
autocreate=True)
approver_ids = list(set(approver_ids_dict.values()))
else:
mr.errors.approvers = 'Please provide at least one default approver.'
if mr.errors.AnyErrors():
new_field_def = field_helpers.ReviseFieldDefFromParsed(parsed, field_def)
new_field_def_view = tracker_views.FieldDefView(
new_field_def, config)
self.PleaseCorrect(
mr,
field_def=new_field_def_view,
initial_applicable_type=parsed.applicable_type,
initial_choices=parsed.choices_text,
initial_admins=admin_str,
initial_editors=editor_str,
initial_approvers=parsed.approvers_str,
initial_is_restricted_field=parsed.is_restricted_field)
return
self.services.config.UpdateFieldDef(
mr.cnxn,
mr.project_id,
field_def.field_id,
applicable_type=parsed.applicable_type,
applicable_predicate=parsed.applicable_predicate,
is_required=parsed.is_required,
is_niche=parsed.is_niche,
min_value=parsed.min_value,
max_value=parsed.max_value,
regex=parsed.regex,
needs_member=parsed.needs_member,
needs_perm=parsed.needs_perm,
grants_perm=parsed.grants_perm,
notify_on=parsed.notify_on,
is_multivalued=parsed.is_multivalued,
date_action=parsed.date_action_str,
docstring=parsed.field_docstring,
admin_ids=admin_ids,
editor_ids=editor_ids,
is_restricted_field=parsed.is_restricted_field)
if field_def.field_type == tracker_pb2.FieldTypes.APPROVAL_TYPE:
approval_defs = field_helpers.ReviseApprovals(
field_def.field_id, approver_ids, parsed.survey, config)
self.services.config.UpdateConfig(
mr.cnxn, mr.project, approval_defs=approval_defs)
if field_def.field_type == tracker_pb2.FieldTypes.ENUM_TYPE:
self.services.config.UpdateConfig(
mr.cnxn, mr.project, well_known_labels=parsed.revised_labels)
return framework_helpers.FormatAbsoluteURL(
mr, urls.FIELD_DETAIL, field=field_def.field_name,
saved=1, ts=int(time.time()))
def GetFieldDetail(self, **kwargs):
return self.handler(**kwargs)
def PostFieldDetail(self, **kwargs):
return self.handler(**kwargs)