def issues_insert(self, request):
"""Add a new issue."""
mar = self.mar_factory(request)
if not mar.perms.CanUsePerm(
permissions.CREATE_ISSUE, mar.auth.effective_ids, mar.project, []):
raise permissions.PermissionException(
'The requester %s is not allowed to create issues for project %s.' %
(mar.auth.email, mar.project_name))
owner_id = None
if request.owner:
try:
owner_id = self._services.user.LookupUserID(
mar.cnxn, request.owner.name)
except user_svc.NoSuchUserException:
raise endpoints.BadRequestException(
'The specified owner %s does not exist.' % request.owner.name)
cc_ids = []
if request.cc:
cc_ids = self._services.user.LookupUserIDs(
mar.cnxn, [ap.name for ap in request.cc],
autocreate=True).values()
comp_ids = api_pb2_v1_helpers.convert_component_ids(
mar.config, request.components)
fields_add, _, _, fields_labels, _ = (
api_pb2_v1_helpers.convert_field_values(
request.fieldValues, mar, self._services))
field_helpers.ValidateCustomFields(
mar, self._services, fields_add, mar.config, mar.errors)
if mar.errors.AnyErrors():
raise endpoints.BadRequestException(
'Invalid field values: %s' % mar.errors.custom_fields)
local_id = self._services.issue.CreateIssue(
mar.cnxn, self._services, mar.project_id,
request.summary, request.status, owner_id,
cc_ids, request.labels + fields_labels, fields_add,
comp_ids, mar.auth.user_id, request.description,
blocked_on=api_pb2_v1_helpers.convert_issueref_pbs(
request.blockedOn, mar, self._services),
blocking=api_pb2_v1_helpers.convert_issueref_pbs(
request.blocking, mar, self._services))
new_issue = self._services.issue.GetIssueByLocalID(
mar.cnxn, mar.project_id, local_id)
self._services.issue_star.SetStar(
mar.cnxn, self._services, mar.config, new_issue.issue_id,
mar.auth.user_id, True)
if request.sendEmail:
notify.PrepareAndSendIssueChangeNotification(
new_issue.issue_id, framework_helpers.GetHostPort(),
new_issue.reporter_id, 0)
return api_pb2_v1_helpers.convert_issue(
api_pb2_v1.IssuesGetInsertResponse, new_issue, mar, self._services)
def testValidateCustomFields_NoErrors(self):
fd = tracker_bizobj.MakeFieldDef(123, 789, 'CPU',
tracker_pb2.FieldTypes.INT_TYPE, None,
'', False, False, False, None, None,
'', False, '', '',
tracker_pb2.NotifyTriggers.NEVER,
'no_action', 'doc', False)
self.config.field_defs.append(fd)
fv1 = tracker_bizobj.MakeFieldValue(123, 8086, None, None, None, False)
fv2 = tracker_bizobj.MakeFieldValue(123, 486, None, None, None, False)
field_helpers.ValidateCustomFields(self.mr, self.services, [fv1, fv2],
self.config, self.errors)
self.assertFalse(self.errors.AnyErrors())
def testValidateCustomFields_SomeErrors(self):
fd = tracker_bizobj.MakeFieldDef(123, 789, 'CPU',
tracker_pb2.FieldTypes.INT_TYPE, None,
'', False, False, False, None, None,
'', False, '', '',
tracker_pb2.NotifyTriggers.NEVER,
'no_action', 'doc', False)
self.config.field_defs.append(fd)
fv1 = tracker_bizobj.MakeFieldValue(123, 8086, None, None, None, False)
fv2 = tracker_bizobj.MakeFieldValue(123, 486, None, None, None, False)
fd.min_value = 1
fd.max_value = 999
field_helpers.ValidateCustomFields(self.mr, self.services, [fv1, fv2],
self.config, self.errors)
self.assertTrue(self.errors.AnyErrors())
self.assertEqual(1, len(self.errors.custom_fields))
custom_field_error = self.errors.custom_fields[0]
self.assertEqual(123, custom_field_error.field_id)
self.assertEqual('Value must be <= 999', custom_field_error.message)
def ProcessFormData(self, mr, post_data):
"""Process the issue entry form.
Args:
mr: commonly used info parsed from the request.
post_data: The post_data dict for the current request.
Returns:
String URL to redirect the user to after processing.
"""
config = self.services.config.GetProjectConfig(mr.cnxn, mr.project_id)
parsed = tracker_helpers.ParseIssueRequest(mr.cnxn, post_data,
self.services, mr.errors,
mr.project_name)
bounce_labels = parsed.labels[:]
bounce_fields = tracker_views.MakeBounceFieldValueViews(
parsed.fields.vals, parsed.fields.phase_vals, config)
field_helpers.ShiftEnumFieldsIntoLabels(parsed.labels,
parsed.labels_remove,
parsed.fields.vals,
parsed.fields.vals_remove,
config)
is_member = framework_bizobj.UserIsInProject(mr.project,
mr.auth.effective_ids)
template = self._GetTemplate(mr.cnxn, config, parsed.template_name,
is_member)
(approval_values,
phases) = issue_tmpl_helpers.FilterApprovalsAndPhases(
template.approval_values or [], template.phases, config)
phase_ids_by_name = {
phase.name.lower(): [phase.phase_id]
for phase in template.phases
}
field_values = field_helpers.ParseFieldValues(
mr.cnxn,
self.services.user,
parsed.fields.vals,
parsed.fields.phase_vals,
config,
phase_ids_by_name=phase_ids_by_name)
labels = _DiscardUnusedTemplateLabelPrefixes(parsed.labels)
component_ids = tracker_helpers.LookupComponentIDs(
parsed.components.paths, config, mr.errors)
# TODO(jrobbins): consider captcha 3 score in API
if not parsed.summary.strip() or parsed.summary == PLACEHOLDER_SUMMARY:
mr.errors.summary = 'Summary is required'
if not parsed.comment.strip():
mr.errors.comment = 'A description is required'
if len(parsed.comment) > tracker_constants.MAX_COMMENT_CHARS:
mr.errors.comment = 'Comment is too long'
if len(parsed.summary) > tracker_constants.MAX_SUMMARY_CHARS:
mr.errors.summary = 'Summary is too long'
if _MatchesTemplate(parsed.comment, template):
mr.errors.comment = 'Template must be filled out.'
if parsed.users.owner_id is None:
mr.errors.owner = 'Invalid owner username'
else:
valid, msg = tracker_helpers.IsValidIssueOwner(
mr.cnxn, mr.project, parsed.users.owner_id, self.services)
if not valid:
mr.errors.owner = msg
if None in parsed.users.cc_ids:
mr.errors.cc = 'Invalid Cc username'
field_helpers.ValidateCustomFields(mr, self.services, field_values,
config, mr.errors)
hotlist_pbs = ProcessParsedHotlistRefs(mr, self.services,
parsed.hotlists.hotlist_refs)
if not mr.errors.AnyErrors():
with work_env.WorkEnv(mr, self.services) as we:
try:
if parsed.attachments:
new_bytes_used = tracker_helpers.ComputeNewQuotaBytesUsed(
mr.project, parsed.attachments)
# TODO(jrobbins): Make quota be calculated and stored as
# part of applying the comment.
self.services.project.UpdateProject(
mr.cnxn,
mr.project.project_id,
attachment_bytes_used=new_bytes_used)
marked_description = tracker_helpers.MarkupDescriptionOnInput(
parsed.comment, template.content)
has_star = 'star' in post_data and post_data['star'] == '1'
if approval_values:
_AttachDefaultApprovers(config, approval_values)
issue, _ = we.CreateIssue(
mr.project_id,
parsed.summary,
parsed.status,
parsed.users.owner_id,
parsed.users.cc_ids,
labels,
field_values,
component_ids,
marked_description,
blocked_on=parsed.blocked_on.iids,
blocking=parsed.blocking.iids,
attachments=parsed.attachments,
approval_values=approval_values,
phases=phases)
if has_star:
we.StarIssue(issue, True)
if hotlist_pbs:
hotlist_ids = {
hotlist.hotlist_id
for hotlist in hotlist_pbs
}
issue_tuple = (issue.issue_id, mr.auth.user_id,
int(time.time()), '')
self.services.features.AddIssueToHotlists(
mr.cnxn, hotlist_ids, issue_tuple,
self.services.issue, self.services.chart)
except tracker_helpers.OverAttachmentQuota:
mr.errors.attachments = 'Project attachment quota exceeded.'
mr.template_name = parsed.template_name
if mr.errors.AnyErrors():
self.PleaseCorrect(
mr,
initial_summary=parsed.summary,
initial_status=parsed.status,
initial_owner=parsed.users.owner_username,
initial_cc=', '.join(parsed.users.cc_usernames),
initial_components=', '.join(parsed.components.paths),
initial_comment=parsed.comment,
labels=bounce_labels,
fields=bounce_fields,
template_name=parsed.template_name,
initial_blocked_on=parsed.blocked_on.entered_str,
initial_blocking=parsed.blocking.entered_str,
initial_hotlists=parsed.hotlists.entered_str,
component_required=ezt.boolean(template.component_required))
return
# format a redirect url
return framework_helpers.FormatAbsoluteURL(mr,
urls.ISSUE_DETAIL,
id=issue.local_id)
def ProcessFormData(self, mr, post_data):
"""Process the posted issue update form.
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 after processing.
"""
if not mr.local_id_list:
logging.info('missing issue local IDs, probably tampered')
self.response.status = httplib.BAD_REQUEST
return
# Check that the user is logged in; anon users cannot update issues.
if not mr.auth.user_id:
logging.info('user was not logged in, cannot update issue')
self.response.status = httplib.BAD_REQUEST # xxx should raise except
return
# Check that the user has permission to add a comment, and to enter
# metadata if they are trying to do that.
if not self.CheckPerm(mr, permissions.ADD_ISSUE_COMMENT):
logging.info('user has no permission to add issue comment')
self.response.status = httplib.BAD_REQUEST
return
if not self.CheckPerm(mr, permissions.EDIT_ISSUE):
logging.info('user has no permission to edit issue metadata')
self.response.status = httplib.BAD_REQUEST
return
move_to = post_data.get('move_to', '').lower()
if move_to and not self.CheckPerm(mr, permissions.DELETE_ISSUE):
logging.info('user has no permission to move issue')
self.response.status = httplib.BAD_REQUEST
return
config = self.services.config.GetProjectConfig(mr.cnxn, mr.project_id)
parsed = tracker_helpers.ParseIssueRequest(mr.cnxn, post_data,
self.services, mr.errors,
mr.project_name)
bounce_labels = (parsed.labels[:] +
['-%s' % lr for lr in parsed.labels_remove])
bounce_fields = tracker_views.MakeBounceFieldValueViews(
parsed.fields.vals, parsed.fields.phase_vals, config)
field_helpers.ShiftEnumFieldsIntoLabels(parsed.labels,
parsed.labels_remove,
parsed.fields.vals,
parsed.fields.vals_remove,
config)
issue_list = self.services.issue.GetIssuesByLocalIDs(
mr.cnxn, mr.project_id, mr.local_id_list)
issue_phases = list(
itertools.chain.from_iterable(issue.phases
for issue in issue_list))
phase_ids_by_name = collections.defaultdict(set)
for phase in issue_phases:
phase_ids_by_name[phase.name.lower()].add(phase.phase_id)
# Note: Not all parsed phase field values will be applicable to every issue.
# tracker_bizobj.ApplyFieldValueChanges will take care of not adding
# phase field values to issues that don't contain the correct phase.
field_vals = field_helpers.ParseFieldValues(
mr.cnxn,
self.services.user,
parsed.fields.vals,
parsed.fields.phase_vals,
config,
phase_ids_by_name=phase_ids_by_name)
field_vals_remove = field_helpers.ParseFieldValues(
mr.cnxn,
self.services.user,
parsed.fields.vals_remove,
parsed.fields.phase_vals_remove,
config,
phase_ids_by_name=phase_ids_by_name)
field_helpers.ValidateCustomFields(mr, self.services, field_vals,
config, mr.errors)
# Treat status '' as no change and explicit 'clear' as clearing the status.
status = parsed.status
if status == '':
status = None
if post_data.get('op_statusenter') == 'clear':
status = ''
reporter_id = mr.auth.user_id
logging.info('bulk edit request by %s', reporter_id)
if parsed.users.owner_id is None:
mr.errors.owner = 'Invalid owner username'
else:
valid, msg = tracker_helpers.IsValidIssueOwner(
mr.cnxn, mr.project, parsed.users.owner_id, self.services)
if not valid:
mr.errors.owner = msg
if (status in config.statuses_offer_merge
and not post_data.get('merge_into')):
mr.errors.merge_into_id = 'Please enter a valid issue ID'
move_to_project = None
if move_to:
if mr.project_name == move_to:
mr.errors.move_to = 'The issues are already in project ' + move_to
else:
move_to_project = self.services.project.GetProjectByName(
mr.cnxn, move_to)
if not move_to_project:
mr.errors.move_to = 'No such project: ' + move_to
# Treat owner '' as no change, and explicit 'clear' as NO_USER_SPECIFIED
owner_id = parsed.users.owner_id
if parsed.users.owner_username == '':
owner_id = None
if post_data.get('op_ownerenter') == 'clear':
owner_id = framework_constants.NO_USER_SPECIFIED
comp_ids = tracker_helpers.LookupComponentIDs(parsed.components.paths,
config, mr.errors)
comp_ids_remove = tracker_helpers.LookupComponentIDs(
parsed.components.paths_remove, config, mr.errors)
if post_data.get('op_componententer') == 'remove':
comp_ids, comp_ids_remove = comp_ids_remove, comp_ids
cc_ids, cc_ids_remove = parsed.users.cc_ids, parsed.users.cc_ids_remove
if post_data.get('op_memberenter') == 'remove':
cc_ids, cc_ids_remove = parsed.users.cc_ids_remove, parsed.users.cc_ids
issue_list_iids = {issue.issue_id for issue in issue_list}
if post_data.get('op_blockedonenter') == 'append':
if issue_list_iids.intersection(parsed.blocked_on.iids):
mr.errors.blocked_on = 'Cannot block an issue on itself.'
blocked_on_add = parsed.blocked_on.iids
blocked_on_remove = []
else:
blocked_on_add = []
blocked_on_remove = parsed.blocked_on.iids
if post_data.get('op_blockingenter') == 'append':
if issue_list_iids.intersection(parsed.blocking.iids):
mr.errors.blocking = 'Cannot block an issue on itself.'
blocking_add = parsed.blocking.iids
blocking_remove = []
else:
blocking_add = []
blocking_remove = parsed.blocking.iids
iids_actually_changed = []
old_owner_ids = []
combined_amendments = []
merge_into_issue = None
new_starrers = set()
if not mr.errors.AnyErrors():
# Because we will modify issues, load from DB rather than cache.
issue_list = self.services.issue.GetIssuesByLocalIDs(
mr.cnxn, mr.project_id, mr.local_id_list, use_cache=False)
# Skip any individual issues that the user is not allowed to edit.
editable_issues = [
issue for issue in issue_list if permissions.CanEditIssue(
mr.auth.effective_ids, mr.perms, mr.project, issue)
]
# Skip any restrict issues that cannot be moved
if move_to:
editable_issues = [
issue for issue in editable_issues
if not permissions.GetRestrictions(issue)
]
# If 'Duplicate' status is specified ensure there are no permission issues
# with the issue we want to merge with.
if post_data.get('merge_into'):
for issue in editable_issues:
_, merge_into_issue = tracker_helpers.ParseMergeFields(
mr.cnxn, self.services, mr.project_name, post_data,
parsed.status, config, issue, mr.errors)
if merge_into_issue:
merge_allowed = tracker_helpers.IsMergeAllowed(
merge_into_issue, mr, self.services)
if not merge_allowed:
mr.errors.merge_into_id = 'Target issue %s cannot be modified' % (
merge_into_issue.local_id)
break
# Update the new_starrers set.
new_starrers.update(
tracker_helpers.GetNewIssueStarrers(
mr.cnxn, self.services, issue.issue_id,
merge_into_issue.issue_id))
# Proceed with amendments only if there are no reported errors.
if not mr.errors.AnyErrors():
# Sort the issues: we want them in this order so that the
# corresponding old_owner_id are found in the same order.
editable_issues.sort(
lambda i1, i2: cmp(i1.local_id, i2.local_id))
iids_to_invalidate = set()
rules = self.services.features.GetFilterRules(
mr.cnxn, config.project_id)
predicate_asts = filterrules_helpers.ParsePredicateASTs(
rules, config, [])
for issue in editable_issues:
old_owner_id = tracker_bizobj.GetOwnerId(issue)
merge_into_iid = (merge_into_issue.issue_id
if merge_into_issue else None)
delta = tracker_bizobj.MakeIssueDelta(
status, owner_id, cc_ids, cc_ids_remove, comp_ids,
comp_ids_remove, parsed.labels, parsed.labels_remove,
field_vals, field_vals_remove,
parsed.fields.fields_clear, blocked_on_add,
blocked_on_remove, blocking_add, blocking_remove,
merge_into_iid, None)
amendments, _ = self.services.issue.DeltaUpdateIssue(
mr.cnxn,
self.services,
mr.auth.user_id,
mr.project_id,
config,
issue,
delta,
comment=parsed.comment,
iids_to_invalidate=iids_to_invalidate,
rules=rules,
predicate_asts=predicate_asts)
if amendments or parsed.comment: # Avoid empty comments.
iids_actually_changed.append(issue.issue_id)
old_owner_ids.append(old_owner_id)
combined_amendments.extend(amendments)
self.services.issue.InvalidateIIDs(mr.cnxn, iids_to_invalidate)
self.services.project.UpdateRecentActivity(
mr.cnxn, mr.project.project_id)
# Add new_starrers and new CCs to merge_into_issue.
if merge_into_issue:
merge_into_project = self.services.project.GetProjectByName(
mr.cnxn, merge_into_issue.project_name)
tracker_helpers.AddIssueStarrers(mr.cnxn, self.services,
mr,
merge_into_issue.issue_id,
merge_into_project,
new_starrers)
tracker_helpers.MergeCCsAndAddCommentMultipleIssues(
self.services, mr, editable_issues, merge_into_issue)
if move_to and editable_issues:
tracker_fulltext.UnindexIssues(
[issue.issue_id for issue in editable_issues])
for issue in editable_issues:
old_text_ref = 'issue %s:%s' % (issue.project_name,
issue.local_id)
moved_back_iids = self.services.issue.MoveIssues(
mr.cnxn, move_to_project, [issue],
self.services.user)
new_text_ref = 'issue %s:%s' % (issue.project_name,
issue.local_id)
if issue.issue_id in moved_back_iids:
content = 'Moved %s back to %s again.' % (
old_text_ref, new_text_ref)
else:
content = 'Moved %s to now be %s.' % (old_text_ref,
new_text_ref)
self.services.issue.CreateIssueComment(
mr.cnxn,
issue,
mr.auth.user_id,
content,
amendments=[
tracker_bizobj.MakeProjectAmendment(
move_to_project.project_name)
])
send_email = 'send_email' in post_data
users_by_id = framework_views.MakeAllUserViews(
mr.cnxn, self.services.user, [owner_id], cc_ids,
cc_ids_remove, old_owner_ids,
tracker_bizobj.UsersInvolvedInAmendments(
combined_amendments))
if move_to and editable_issues:
iids_actually_changed = [
issue.issue_id for issue in editable_issues
]
send_notifications.SendIssueBulkChangeNotification(
iids_actually_changed, mr.request.host, old_owner_ids,
parsed.comment, reporter_id, combined_amendments,
send_email, users_by_id)
if mr.errors.AnyErrors():
bounce_cc_parts = (
parsed.users.cc_usernames +
['-%s' % ccur for ccur in parsed.users.cc_usernames_remove])
self.PleaseCorrect(
mr,
initial_status=parsed.status,
initial_owner=parsed.users.owner_username,
initial_merge_into=post_data.get('merge_into', 0),
initial_cc=', '.join(bounce_cc_parts),
initial_comment=parsed.comment,
initial_components=parsed.components.entered_str,
labels=bounce_labels,
fields=bounce_fields)
return
with mr.profiler.Phase('reindexing issues'):
logging.info('starting reindexing')
start = time.time()
# Get the updated issues and index them
issue_list = self.services.issue.GetIssuesByLocalIDs(
mr.cnxn, mr.project_id, mr.local_id_list)
tracker_fulltext.IndexIssues(mr.cnxn, issue_list,
self.services.user,
self.services.issue,
self.services.config)
logging.info('reindexing %d issues took %s sec', len(issue_list),
time.time() - start)
# TODO(jrobbins): These could be put into the form action attribute.
mr.can = int(post_data['can'])
mr.query = post_data['q']
mr.col_spec = post_data['colspec']
mr.sort_spec = post_data['sort']
mr.group_by_spec = post_data['groupby']
mr.start = int(post_data['start'])
mr.num = int(post_data['num'])
# TODO(jrobbins): implement bulk=N param for a better confirmation alert.
return tracker_helpers.FormatIssueListURL(mr,
config,
saved=len(mr.local_id_list),
ts=int(time.time()))
def testValidateCustomFields_NoCustomFieldValues(self):
field_helpers.ValidateCustomFields(self.mr, self.services, [],
self.config, self.errors)
self.assertFalse(self.errors.AnyErrors())
def ProcessFormData(self, mr, post_data):
"""Process the issue entry form.
Args:
mr: commonly used info parsed from the request.
post_data: The post_data dict for the current request.
Returns:
String URL to redirect the user to after processing.
"""
config = self.services.config.GetProjectConfig(mr.cnxn, mr.project_id)
parsed = tracker_helpers.ParseIssueRequest(
mr.cnxn, post_data, self.services, mr.errors, mr.project_name)
bounce_labels = parsed.labels[:]
bounce_fields = tracker_views.MakeBounceFieldValueViews(
parsed.fields.vals, config)
field_helpers.ShiftEnumFieldsIntoLabels(
parsed.labels, parsed.labels_remove, parsed.fields.vals,
parsed.fields.vals_remove, config)
field_values = field_helpers.ParseFieldValues(
mr.cnxn, self.services.user, parsed.fields.vals, config)
labels = _DiscardUnusedTemplateLabelPrefixes(parsed.labels)
component_ids = tracker_helpers.LookupComponentIDs(
parsed.components.paths, config, mr.errors)
reporter_id = mr.auth.user_id
self.CheckCaptcha(mr, post_data)
if not parsed.summary.strip() or parsed.summary == PLACEHOLDER_SUMMARY:
mr.errors.summary = 'Summary is required'
if not parsed.comment.strip():
mr.errors.comment = 'A description is required'
if len(parsed.comment) > tracker_constants.MAX_COMMENT_CHARS:
mr.errors.comment = 'Comment is too long'
if len(parsed.summary) > tracker_constants.MAX_SUMMARY_CHARS:
mr.errors.summary = 'Summary is too long'
if _MatchesTemplate(parsed.comment, config):
mr.errors.comment = 'Template must be filled out.'
if parsed.users.owner_id is None:
mr.errors.owner = 'Invalid owner username'
else:
valid, msg = tracker_helpers.IsValidIssueOwner(
mr.cnxn, mr.project, parsed.users.owner_id, self.services)
if not valid:
mr.errors.owner = msg
if None in parsed.users.cc_ids:
mr.errors.cc = 'Invalid Cc username'
field_helpers.ValidateCustomFields(
mr, self.services, field_values, config, mr.errors)
new_local_id = None
if not mr.errors.AnyErrors():
try:
if parsed.attachments:
new_bytes_used = tracker_helpers.ComputeNewQuotaBytesUsed(
mr.project, parsed.attachments)
self.services.project.UpdateProject(
mr.cnxn, mr.project.project_id,
attachment_bytes_used=new_bytes_used)
template_content = ''
for wkp in config.templates:
if wkp.name == parsed.template_name:
template_content = wkp.content
marked_comment = _MarkupDescriptionOnInput(
parsed.comment, template_content)
has_star = 'star' in post_data and post_data['star'] == '1'
new_local_id = self.services.issue.CreateIssue(
mr.cnxn, self.services,
mr.project_id, parsed.summary, parsed.status, parsed.users.owner_id,
parsed.users.cc_ids, labels, field_values,
component_ids, reporter_id, marked_comment,
blocked_on=parsed.blocked_on.iids, blocking=parsed.blocking.iids,
attachments=parsed.attachments)
self.services.project.UpdateRecentActivity(
mr.cnxn, mr.project.project_id)
issue = self.services.issue.GetIssueByLocalID(
mr.cnxn, mr.project_id, new_local_id)
if has_star:
self.services.issue_star.SetStar(
mr.cnxn, self.services, config, issue.issue_id, reporter_id, True)
except tracker_helpers.OverAttachmentQuota:
mr.errors.attachments = 'Project attachment quota exceeded.'
counts = {actionlimit.ISSUE_COMMENT: 1,
actionlimit.ISSUE_ATTACHMENT: len(parsed.attachments)}
self.CountRateLimitedActions(mr, counts)
if mr.errors.AnyErrors():
component_required = False
for wkp in config.templates:
if wkp.name == parsed.template_name:
component_required = wkp.component_required
self.PleaseCorrect(
mr, initial_summary=parsed.summary, initial_status=parsed.status,
initial_owner=parsed.users.owner_username,
initial_cc=', '.join(parsed.users.cc_usernames),
initial_components=', '.join(parsed.components.paths),
initial_comment=parsed.comment, labels=bounce_labels,
fields=bounce_fields,
initial_blocked_on=parsed.blocked_on.entered_str,
initial_blocking=parsed.blocking.entered_str,
component_required=ezt.boolean(component_required))
return
# Initial description is comment 0.
notify.PrepareAndSendIssueChangeNotification(
issue.issue_id, mr.request.host, reporter_id, 0)
notify.PrepareAndSendIssueBlockingNotification(
issue.issue_id, mr.request.host, parsed.blocked_on.iids, reporter_id)
# format a redirect url
return framework_helpers.FormatAbsoluteURL(
mr, urls.ISSUE_DETAIL, id=new_local_id)
def issues_comments_insert(self, request):
"""Add a comment."""
mar = self.mar_factory(request)
issue = self._services.issue.GetIssueByLocalID(
mar.cnxn, mar.project_id, request.issueId)
old_owner_id = tracker_bizobj.GetOwnerId(issue)
if not permissions.CanCommentIssue(
mar.auth.effective_ids, mar.perms, mar.project, issue,
mar.granted_perms):
raise permissions.PermissionException(
'User is not allowed to comment this issue (%s, %d)' %
(request.projectId, request.issueId))
updates_dict = {}
if request.updates:
if request.updates.moveToProject:
move_to = request.updates.moveToProject.lower()
move_to_project = issuedetail.CheckMoveIssueRequest(
self._services, mar, issue, True, move_to, mar.errors)
if mar.errors.AnyErrors():
raise endpoints.BadRequestException(mar.errors.move_to)
updates_dict['move_to_project'] = move_to_project
updates_dict['summary'] = request.updates.summary
updates_dict['status'] = request.updates.status
if request.updates.owner:
if request.updates.owner == framework_constants.NO_USER_NAME:
updates_dict['owner'] = framework_constants.NO_USER_SPECIFIED
else:
updates_dict['owner'] = self._services.user.LookupUserID(
mar.cnxn, request.updates.owner)
updates_dict['cc_add'], updates_dict['cc_remove'] = (
api_pb2_v1_helpers.split_remove_add(request.updates.cc))
updates_dict['cc_add'] = self._services.user.LookupUserIDs(
mar.cnxn, updates_dict['cc_add'], autocreate=True).values()
updates_dict['cc_remove'] = self._services.user.LookupUserIDs(
mar.cnxn, updates_dict['cc_remove']).values()
updates_dict['labels_add'], updates_dict['labels_remove'] = (
api_pb2_v1_helpers.split_remove_add(request.updates.labels))
blocked_on_add_strs, blocked_on_remove_strs = (
api_pb2_v1_helpers.split_remove_add(request.updates.blockedOn))
updates_dict['blocked_on_add'] = api_pb2_v1_helpers.issue_global_ids(
blocked_on_add_strs, issue.project_id, mar,
self._services)
updates_dict['blocked_on_remove'] = api_pb2_v1_helpers.issue_global_ids(
blocked_on_remove_strs, issue.project_id, mar,
self._services)
blocking_add_strs, blocking_remove_strs = (
api_pb2_v1_helpers.split_remove_add(request.updates.blocking))
updates_dict['blocking_add'] = api_pb2_v1_helpers.issue_global_ids(
blocking_add_strs, issue.project_id, mar,
self._services)
updates_dict['blocking_remove'] = api_pb2_v1_helpers.issue_global_ids(
blocking_remove_strs, issue.project_id, mar,
self._services)
components_add_strs, components_remove_strs = (
api_pb2_v1_helpers.split_remove_add(request.updates.components))
updates_dict['components_add'] = (
api_pb2_v1_helpers.convert_component_ids(
mar.config, components_add_strs))
updates_dict['components_remove'] = (
api_pb2_v1_helpers.convert_component_ids(
mar.config, components_remove_strs))
if request.updates.mergedInto:
merge_project_name, merge_local_id = tracker_bizobj.ParseIssueRef(
request.updates.mergedInto)
merge_into_project = self._services.project.GetProjectByName(
mar.cnxn, merge_project_name or issue.project_name)
merge_into_issue = self._services.issue.GetIssueByLocalID(
mar.cnxn, merge_into_project.project_id, merge_local_id)
merge_allowed = tracker_helpers.IsMergeAllowed(
merge_into_issue, mar, self._services)
if not merge_allowed:
raise permissions.PermissionException(
'User is not allowed to merge into issue %s:%s' %
(merge_into_issue.project_name, merge_into_issue.local_id))
updates_dict['merged_into'] = merge_into_issue.issue_id
(updates_dict['field_vals_add'], updates_dict['field_vals_remove'],
updates_dict['fields_clear'], updates_dict['fields_labels_add'],
updates_dict['fields_labels_remove']) = (
api_pb2_v1_helpers.convert_field_values(
request.updates.fieldValues, mar, self._services))
field_helpers.ValidateCustomFields(
mar, self._services,
(updates_dict.get('field_vals_add', []) +
updates_dict.get('field_vals_remove', [])),
mar.config, mar.errors)
if mar.errors.AnyErrors():
raise endpoints.BadRequestException(
'Invalid field values: %s' % mar.errors.custom_fields)
_, comment = self._services.issue.DeltaUpdateIssue(
cnxn=mar.cnxn, services=self._services,
reporter_id=mar.auth.user_id,
project_id=mar.project_id, config=mar.config, issue=issue,
status=updates_dict.get('status'), owner_id=updates_dict.get('owner'),
cc_add=updates_dict.get('cc_add', []),
cc_remove=updates_dict.get('cc_remove', []),
comp_ids_add=updates_dict.get('components_add', []),
comp_ids_remove=updates_dict.get('components_remove', []),
labels_add=(updates_dict.get('labels_add', []) +
updates_dict.get('fields_labels_add', [])),
labels_remove=(updates_dict.get('labels_remove', []) +
updates_dict.get('fields_labels_remove', [])),
field_vals_add=updates_dict.get('field_vals_add', []),
field_vals_remove=updates_dict.get('field_vals_remove', []),
fields_clear=updates_dict.get('fields_clear', []),
blocked_on_add=updates_dict.get('blocked_on_add', []),
blocked_on_remove=updates_dict.get('blocked_on_remove', []),
blocking_add=updates_dict.get('blocking_add', []),
blocking_remove=updates_dict.get('blocking_remove', []),
merged_into=updates_dict.get('merged_into'),
index_now=False,
comment=request.content,
summary=updates_dict.get('summary'),
)
move_comment = None
if 'move_to_project' in updates_dict:
move_to_project = updates_dict['move_to_project']
old_text_ref = 'issue %s:%s' % (issue.project_name, issue.local_id)
tracker_fulltext.UnindexIssues([issue.issue_id])
moved_back_iids = self._services.issue.MoveIssues(
mar.cnxn, move_to_project, [issue], self._services.user)
new_text_ref = 'issue %s:%s' % (issue.project_name, issue.local_id)
if issue.issue_id in moved_back_iids:
content = 'Moved %s back to %s again.' % (old_text_ref, new_text_ref)
else:
content = 'Moved %s to now be %s.' % (old_text_ref, new_text_ref)
move_comment = self._services.issue.CreateIssueComment(
mar.cnxn, move_to_project.project_id, issue.local_id, mar.auth.user_id,
content, amendments=[
tracker_bizobj.MakeProjectAmendment(move_to_project.project_name)])
if 'merged_into' in updates_dict:
new_starrers = tracker_helpers.GetNewIssueStarrers(
mar.cnxn, self._services, issue.issue_id, merge_into_issue.issue_id)
tracker_helpers.AddIssueStarrers(
mar.cnxn, self._services, mar,
merge_into_issue.issue_id, merge_into_project, new_starrers)
_merge_comment = tracker_helpers.MergeCCsAndAddComment(
self._services, mar, issue, merge_into_project, merge_into_issue)
merge_into_issue_cmnts = self._services.issue.GetCommentsForIssue(
mar.cnxn, merge_into_issue.issue_id)
notify.PrepareAndSendIssueChangeNotification(
merge_into_issue.issue_id, framework_helpers.GetHostPort(),
mar.auth.user_id, len(merge_into_issue_cmnts) - 1, send_email=True)
tracker_fulltext.IndexIssues(
mar.cnxn, [issue], self._services.user, self._services.issue,
self._services.config)
comment = comment or move_comment
if comment is None:
return api_pb2_v1.IssuesCommentsInsertResponse()
cmnts = self._services.issue.GetCommentsForIssue(mar.cnxn, issue.issue_id)
seq = len(cmnts) - 1
if request.sendEmail:
notify.PrepareAndSendIssueChangeNotification(
issue.issue_id, framework_helpers.GetHostPort(),
comment.user_id, seq, send_email=True, old_owner_id=old_owner_id)
can_delete = permissions.CanDelete(
mar.auth.user_id, mar.auth.effective_ids, mar.perms,
comment.deleted_by, comment.user_id, mar.project,
permissions.GetRestrictions(issue), granted_perms=mar.granted_perms)
return api_pb2_v1.IssuesCommentsInsertResponse(
id=seq,
kind='monorail#issueComment',
author=api_pb2_v1_helpers.convert_person(
comment.user_id, mar.cnxn, self._services),
content=comment.content,
published=datetime.datetime.fromtimestamp(comment.timestamp),
updates=api_pb2_v1_helpers.convert_amendments(
issue, comment.amendments, mar, self._services),
canDelete=can_delete)
