def get(self, request, *args, **kwargs):
"""Returns the original file.
The file is returned as :mimetype:`text/plain` and is the original
file before applying a patch.
"""
result = self.get_filediff(request, *args, **kwargs)
if isinstance(result, FileDiff):
filediff = result
elif isinstance(result, WebAPIError):
return result
else:
raise ValueError('Unexpected result from get_filediff')
if filediff.is_new:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(
filediff, request,
filediff.diffset.repository.get_encoding_list())
except Exception as e:
logging.error('%s: Error retrieving original file for FileDiff '
'%s: %s',
self.__class__.__name__, filediff.pk, e, exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(orig_file, content_type='text/plain')
filename = urllib_quote(filediff.source_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def raw_diff(request, review_request_id, revision=None, local_site_name=None):
"""
Displays a raw diff of all the filediffs in a diffset for the
given review request.
"""
review_request, response = \
_find_review_request(request, review_request_id, local_site_name)
if not review_request:
return response
diffset = _query_for_diff(review_request, request.user, revision)
tool = review_request.repository.get_scmtool()
data = tool.get_parser('').raw_diff(diffset)
resp = HttpResponse(data, mimetype='text/x-patch')
if diffset.name == 'diff':
filename = "bug%s.patch" % review_request.bugs_closed.replace(',', '_')
else:
filename = diffset.name
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, diffset.timestamp)
return resp
def get(self, request, diffset_id=None, *args, **kwargs):
"""Returns the original unpatched file.
The file is returned as :mimetype:`text/plain` and is the original
file before applying a patch.
"""
try:
attached_diffset = DiffSet.objects.filter(pk=diffset_id, history__isnull=True)
if attached_diffset.exists():
filediff_resource = resources.filediff
else:
filediff_resource = resources.draft_filediff
filediff = filediff_resource.get_object(request, diffset=diffset_id, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if filediff.is_new:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(filediff, request, filediff.diffset.repository.get_encoding_list())
except Exception as e:
logging.error("Error retrieving original file: %s", e, exc_info=1, request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(orig_file, mimetype="text/plain")
filename = urllib_quote(filediff.source_file)
resp["Content-Disposition"] = "inline; filename=%s" % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def get(self, request, *args, **kwargs):
"""Return information about a commit.
If the :mimetype:`text/x-patch` mimetype is requested, the contents of
the patch will be returned.
Otherwise, metadata about the commit (such as author name, author date,
etc.) will be returned.
"""
mimetype = get_http_requested_mimetype(
request, [mimetype['item'] for mimetype in self.allowed_mimetypes])
if mimetype != 'text/x-patch':
return super(DiffCommitResource, self).get(request, *args,
**kwargs)
try:
review_request = resources.review_request.get_object(
request, *args, **kwargs)
commit = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, commit, *args, **kwargs):
return self.get_no_access_error(request)
tool = review_request.repository.get_scmtool()
data = tool.get_parser('').raw_diff(commit)
rsp = HttpResponse(data, content_type=mimetype)
rsp['Content-Disposition'] = ('inline; filename=%s.patch' %
commit.commit_id)
set_last_modified(rsp, commit.last_modified)
return rsp
def raw_diff(request,
review_request_id,
revision=None,
local_site_name=None):
"""
Displays a raw diff of all the filediffs in a diffset for the
given review request.
"""
review_request, response = \
_find_review_request(request, review_request_id, local_site_name)
if not review_request:
return response
diffset = _query_for_diff(review_request, request.user, revision)
tool = review_request.repository.get_scmtool()
data = tool.get_parser('').raw_diff(diffset)
resp = HttpResponse(data, mimetype='text/x-patch')
if diffset.name == 'diff':
filename = "bug%s.patch" % review_request.bugs_closed.replace(',', '_')
else:
filename = diffset.name
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, diffset.timestamp)
return resp
def get(self, request, api_format, *args, **kwargs):
"""Handles HTTP GETs to individual object resources.
By default, this will check for access permissions and query for
the object. It will then return a serialized form of the object.
This may need to be overridden if needing more complex logic.
"""
if (not self.model
or (self.uri_object_key is None and not self.singleton)):
return HttpResponseNotAllowed(self.allowed_methods)
try:
obj = self.get_object(request, *args, **kwargs)
except self.model.DoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, obj, *args, **kwargs):
if request.user.is_authenticated():
return PERMISSION_DENIED
else:
return NOT_LOGGED_IN
last_modified_timestamp = self.get_last_modified(request, obj)
if (last_modified_timestamp
and get_modified_since(request, last_modified_timestamp)):
return HttpResponseNotModified()
etag = self.get_etag(request, obj)
if etag and etag_if_none_match(request, etag):
return HttpResponseNotModified()
data = {
self.item_result_key:
self.serialize_object(obj, request=request, *args, **kwargs),
}
response = WebAPIResponse(request,
status=200,
obj=data,
api_format=api_format,
**self.build_response_args(request))
if last_modified_timestamp:
set_last_modified(response, last_modified_timestamp)
if etag:
set_etag(response, etag)
return response
def get(self, request, *args, **kwargs):
"""Returns the patched file.
The file is returned as :mimetype:`text/plain` and is the result
of applying the patch to the original file.
"""
result = self.get_filediff(request, *args, **kwargs)
if isinstance(result, FileDiff):
filediff = result
elif isinstance(result, WebAPIError):
return result
else:
raise ValueError('Unexpected result from get_filediff')
if filediff.deleted:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(filediff=filediff, request=request)
except Exception as e:
logging.error(
'%s: Error retrieving original file for FileDiff '
'%s: %s',
self.__class__.__name__,
filediff.pk,
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(source_data=orig_file,
filediff=filediff,
request=request)
except Exception as e:
logging.error(
'%s: Error retrieving patched file for FileDiff '
'%s: %s',
self.__class__.__name__,
filediff.pk,
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, content_type='text/plain')
filename = urllib_quote(filediff.dest_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def get(self, request, api_format, *args, **kwargs):
"""Handles HTTP GETs to individual object resources.
By default, this will check for access permissions and query for
the object. It will then return a serialized form of the object.
This may need to be overridden if needing more complex logic.
"""
if (not self.model or
(self.uri_object_key is None and not self.singleton)):
return HttpResponseNotAllowed(self.allowed_methods)
try:
obj = self.get_object(request, *args, **kwargs)
except self.model.DoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, obj, *args, **kwargs):
if request.user.is_authenticated():
return PERMISSION_DENIED
else:
return NOT_LOGGED_IN
last_modified_timestamp = self.get_last_modified(request, obj)
if (last_modified_timestamp and
get_modified_since(request, last_modified_timestamp)):
return HttpResponseNotModified()
etag = self.get_etag(request, obj)
if etag and etag_if_none_match(request, etag):
return HttpResponseNotModified()
data = {
self.item_result_key: self.serialize_object(obj, request=request,
*args, **kwargs),
}
response = WebAPIResponse(request,
status=200,
obj=data,
api_format=api_format,
**self.build_response_args(request))
if last_modified_timestamp:
set_last_modified(response, last_modified_timestamp)
if etag:
set_etag(response, etag)
return response
def _get_patch(self, request, *args, **kwargs):
try:
resources.review_request.get_object(request, *args, **kwargs)
filediff = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
resp = HttpResponse(filediff.diff, content_type='text/x-patch')
filename = '%s.patch' % urllib_quote(filediff.source_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def _get_patch(self, request, *args, **kwargs):
try:
resources.review_request.get_object(request, *args, **kwargs)
filediff = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
resp = HttpResponse(filediff.diff, mimetype='text/x-patch')
filename = '%s.patch' % urllib_quote(filediff.source_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def get(self, request, diffset_id=None, *args, **kwargs):
"""Returns the patched file.
The file is returned as :mimetype:`text/plain` and is the result
of applying the patch to the original file.
"""
try:
attached_diffset = DiffSet.objects.filter(pk=diffset_id,
history__isnull=True)
if attached_diffset.exists():
filediff_resource = resources.filediff
else:
filediff_resource = resources.draft_filediff
filediff = filediff_resource.get_object(request,
diffset=diffset_id,
*args,
**kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if filediff.deleted:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(
filediff, request,
filediff.diffset.repository.get_encoding_list())
except Exception as e:
logging.error("Error retrieving original file: %s",
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(orig_file, filediff, request)
except Exception as e:
logging.error("Error retrieving patched file: %s",
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, mimetype='text/plain')
filename = urllib_quote(filediff.dest_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def comment_diff_fragments(
request,
review_request_id,
comment_ids,
template_name='reviews/load_diff_comment_fragments.js',
comment_template_name='reviews/diff_comment_fragment.html',
error_template_name='diffviewer/diff_fragment_error.html',
local_site_name=None):
"""
Returns the fragment representing the parts of a diff referenced by the
specified list of comment IDs. This is used to allow batch lazy-loading
of these diff fragments based on filediffs, since they may not be cached
and take time to generate.
"""
# While we don't actually need the review request, we still want to do this
# lookup in order to get the permissions checking.
review_request, response = \
_find_review_request(request, review_request_id, local_site_name)
if not review_request:
return response
comments = get_list_or_404(Comment, pk__in=comment_ids.split(","))
latest_timestamp = get_latest_timestamp(
[comment.timestamp for comment in comments])
if get_modified_since(request, latest_timestamp):
return HttpResponseNotModified()
context = RequestContext(
request, {
'comment_entries': [],
'container_prefix': request.GET.get('container_prefix'),
'queue_name': request.GET.get('queue'),
})
had_error, context['comment_entries'] = \
build_diff_comment_fragments(comments,
context,
comment_template_name,
error_template_name)
page_content = render_to_string(template_name, context)
if had_error:
return HttpResponseServerError(page_content)
response = HttpResponse(page_content)
set_last_modified(response, comment.timestamp)
response['Expires'] = http_date(time.time() + 60 * 60 * 24 * 365) # 1 year
return response
def comment_diff_fragments(
request,
review_request_id,
comment_ids,
template_name='reviews/load_diff_comment_fragments.js',
comment_template_name='reviews/diff_comment_fragment.html',
error_template_name='diffviewer/diff_fragment_error.html',
local_site_name=None):
"""
Returns the fragment representing the parts of a diff referenced by the
specified list of comment IDs. This is used to allow batch lazy-loading
of these diff fragments based on filediffs, since they may not be cached
and take time to generate.
"""
# While we don't actually need the review request, we still want to do this
# lookup in order to get the permissions checking.
review_request, response = \
_find_review_request(request, review_request_id, local_site_name)
if not review_request:
return response
comments = get_list_or_404(Comment, pk__in=comment_ids.split(","))
latest_timestamp = get_latest_timestamp([comment.timestamp
for comment in comments])
if get_modified_since(request, latest_timestamp):
return HttpResponseNotModified()
context = RequestContext(request, {
'comment_entries': [],
'container_prefix': request.GET.get('container_prefix'),
'queue_name': request.GET.get('queue'),
})
had_error, context['comment_entries'] = \
build_diff_comment_fragments(comments,
context,
comment_template_name,
error_template_name)
page_content = render_to_string(template_name, context)
if had_error:
return HttpResponseServerError(page_content)
response = HttpResponse(page_content)
set_last_modified(response, comment.timestamp)
response['Expires'] = http_date(time.time() + 60 * 60 * 24 * 365) # 1 year
return response
def get(self, request, *args, **kwargs):
"""Returns the patched file.
The file is returned as :mimetype:`text/plain` and is the result
of applying the patch to the original file.
"""
result = self.get_filediff(request, *args, **kwargs)
if isinstance(result, FileDiff):
filediff = result
elif isinstance(result, WebAPIError):
return result
else:
raise ValueError("Unexpected result from get_filediff")
if filediff.deleted:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(filediff, request, filediff.diffset.repository.get_encoding_list())
except Exception as e:
logging.error(
"%s: Error retrieving original file for FileDiff " "%s: %s",
self.__class__.__name__,
filediff.pk,
e,
exc_info=1,
request=request,
)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(orig_file, filediff, request)
except Exception as e:
logging.error(
"%s: Error retrieving patched file for FileDiff %" "%s: %s",
self.__class__.__name__,
filediff.pk,
e,
exc_info=1,
request=request,
)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, content_type="text/plain")
filename = urllib_quote(filediff.dest_file)
resp["Content-Disposition"] = "inline; filename=%s" % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def get(self, request, api_format, *args, **kwargs):
"""Handles HTTP GETs to individual object resources.
By default, this will check for access permissions and query for
the object. It will then return a serialized form of the object.
This may need to be overridden if needing more complex logic.
"""
if (not self.model or
(self.uri_object_key is None and not self.singleton)):
return HttpResponseNotAllowed(self.allowed_methods)
try:
obj = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, obj, *args, **kwargs):
return self.get_no_access_error(request, obj=obj, *args, **kwargs)
last_modified_timestamp = self.get_last_modified(request, obj)
etag = self.get_etag(request, obj, **kwargs)
if self.are_cache_headers_current(request, last_modified_timestamp,
etag):
return HttpResponseNotModified()
data = {
self.item_result_key: self.serialize_object(obj, request=request,
*args, **kwargs),
}
response = WebAPIResponse(request,
status=200,
obj=data,
api_format=api_format,
**self.build_response_args(request))
if last_modified_timestamp:
set_last_modified(response, last_modified_timestamp)
if etag:
set_etag(response, etag)
return response
def get(self, request, diff_revision=None, *args, **kwargs):
"""Returns the patched file.
The file is returned as :mimetype:`text/plain` and is the result
of applying the patch to the original file.
"""
try:
attached_diffset = DiffSet.objects.filter(revision=diff_revision,
history__isnull=True)
if attached_diffset.exists():
filediff_resource = resources.filediff
else:
filediff_resource = resources.draft_filediff
filediff = filediff_resource.get_object(
request, diff_revision=diff_revision, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if filediff.deleted:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(
filediff, request,
filediff.diffset.repository.get_encoding_list())
except Exception as e:
logging.error("Error retrieving original file: %s", e, exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(orig_file, filediff, request)
except Exception as e:
logging.error("Error retrieving patched file: %s", e, exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, mimetype='text/plain')
filename = urllib_quote(filediff.dest_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def get(self, request, api_format, *args, **kwargs):
"""Handles HTTP GETs to individual object resources.
By default, this will check for access permissions and query for
the object. It will then return a serialized form of the object.
This may need to be overridden if needing more complex logic.
"""
if (not self.model
or (self.uri_object_key is None and not self.singleton)):
return HttpResponseNotAllowed(self.allowed_methods)
try:
obj = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, obj, *args, **kwargs):
return self.get_no_access_error(request, obj=obj, *args, **kwargs)
last_modified_timestamp = self.get_last_modified(request, obj)
etag = self.get_etag(request, obj, **kwargs)
if self.are_cache_headers_current(request, last_modified_timestamp,
etag):
return HttpResponseNotModified()
data = {
self.item_result_key:
self.serialize_object(obj, request=request, *args, **kwargs),
}
response = WebAPIResponse(request,
status=200,
obj=data,
api_format=api_format,
**self.build_response_args(request))
if last_modified_timestamp:
set_last_modified(response, last_modified_timestamp)
if etag:
set_etag(response, etag)
return response
def comment_diff_fragments(
request,
review_request_id,
comment_ids,
template_name="reviews/load_diff_comment_fragments.js",
comment_template_name="reviews/diff_comment_fragment.html",
error_template_name="diffviewer/diff_fragment_error.html",
):
"""
Returns the fragment representing the parts of a diff referenced by the
specified list of comment IDs. This is used to allow batch lazy-loading
of these diff fragments based on filediffs, since they may not be cached
and take time to generate.
"""
comments = get_list_or_404(Comment, pk__in=comment_ids.split(","))
latest_timestamp = get_latest_timestamp([comment.timestamp for comment in comments])
if get_modified_since(request, latest_timestamp):
return HttpResponseNotModified()
context = RequestContext(
request,
{
"comment_entries": [],
"container_prefix": request.GET.get("container_prefix"),
"queue_name": request.GET.get("queue"),
},
)
had_error, context["comment_entries"] = build_diff_comment_fragments(
comments, context, comment_template_name, error_template_name
)
page_content = render_to_string(template_name, context)
if had_error:
return HttpResponseServerError(page_content)
response = HttpResponse(page_content)
set_last_modified(response, comment.timestamp)
response["Expires"] = http_date(time.time() + 60 * 60 * 24 * 365) # 1 year
return response
def raw_diff(request, review_request_id, revision=None):
"""
Displays a raw diff of all the filediffs in a diffset for the
given review request.
"""
review_request = get_object_or_404(ReviewRequest, pk=review_request_id)
diffset = _query_for_diff(review_request, request.user, revision)
data = ''.join([filediff.diff for filediff in diffset.files.all()])
resp = HttpResponse(data, mimetype='text/x-patch')
if diffset.name == 'diff':
filename = "bug%s.patch" % review_request.bugs_closed.replace(',', '_')
else:
filename = diffset.name
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, diffset.timestamp)
return resp
def raw_diff(request, review_request_id, revision=None):
"""
Displays a raw diff of all the filediffs in a diffset for the
given review request.
"""
review_request = get_object_or_404(ReviewRequest, pk=review_request_id)
diffset = _query_for_diff(review_request, request.user, revision)
tool = review_request.repository.get_scmtool()
data = tool.get_parser("").raw_diff(diffset)
resp = HttpResponse(data, mimetype="text/x-patch")
if diffset.name == "diff":
filename = "bug%s.patch" % review_request.bugs_closed.replace(",", "_")
else:
filename = diffset.name
resp["Content-Disposition"] = "inline; filename=%s" % filename
set_last_modified(resp, diffset.timestamp)
return resp
def _get_diff_data(self, request, mimetype, *args, **kwargs):
try:
resources.review_request.get_object(request, *args, **kwargs)
filediff = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
highlighting = request.GET.get('syntax-highlighting', False)
files = get_diff_files(diffset=filediff.diffset,
filediff=filediff,
request=request)
populate_diff_chunks(files, highlighting, request=request)
if not files:
# This may not be the right error here.
return DOES_NOT_EXIST
assert len(files) == 1
f = files[0]
payload = {
'diff_data': {
'binary': f['binary'],
'chunks': f['chunks'],
'num_changes': f['num_changes'],
'changed_chunk_indexes': f['changed_chunk_indexes'],
'new_file': f['newfile'],
}
}
# XXX: Kind of a hack.
api_format = mimetype.split('+')[-1]
resp = WebAPIResponse(request, payload, api_format=api_format)
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def _get_diff_data(self, request, mimetype, *args, **kwargs):
try:
resources.review_request.get_object(request, *args, **kwargs)
filediff = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
highlighting = request.GET.get('syntax-highlighting', False)
files = get_diff_files(diffset=filediff.diffset,
filediff=filediff,
request=request)
populate_diff_chunks(files, highlighting, request=request)
if not files:
# This may not be the right error here.
return DOES_NOT_EXIST
assert len(files) == 1
f = files[0]
payload = {
'diff_data': {
'binary': f['binary'],
'chunks': f['chunks'],
'num_changes': f['num_changes'],
'changed_chunk_indexes': f['changed_chunk_indexes'],
'new_file': f['newfile'],
}
}
# XXX: Kind of a hack.
api_format = mimetype.split('+')[-1]
resp = WebAPIResponse(request, payload, api_format=api_format)
set_last_modified(resp, filediff.diffset.timestamp)
return resp
def _get_patch(self, request, *args, **kwargs):
try:
review_request = \
resources.review_request.get_object(request, *args, **kwargs)
diffset = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
tool = review_request.repository.get_scmtool()
data = tool.get_parser(b'').raw_diff(diffset)
resp = HttpResponse(data, content_type='text/x-patch')
if diffset.name == 'diff':
filename = 'bug%s.patch' % \
review_request.bugs_closed.replace(',', '_')
else:
filename = diffset.name
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, diffset.timestamp)
return resp
def _get_patch(self, request, *args, **kwargs):
try:
review_request = \
resources.review_request.get_object(request, *args, **kwargs)
diffset = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
tool = review_request.repository.get_scmtool()
data = tool.get_parser('').raw_diff(diffset)
resp = HttpResponse(data, content_type='text/x-patch')
if diffset.name == 'diff':
filename = 'bug%s.patch' % \
review_request.bugs_closed.replace(',', '_')
else:
filename = diffset.name
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, diffset.timestamp)
return resp
def get(self, request, *args, **kwargs):
"""Return information about a commit.
If the :mimetype:`text/x-patch` mimetype is requested, the contents of
the patch will be returned.
Otherwise, metadata about the commit (such as author name, author date,
etc.) will be returned.
"""
mimetype = get_http_requested_mimetype(
request,
[mimetype['item'] for mimetype in self.allowed_mimetypes])
if mimetype != 'text/x-patch':
return super(DiffCommitResource, self).get(request, *args,
**kwargs)
try:
review_request = resources.review_request.get_object(
request, *args, **kwargs)
commit = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if not self.has_access_permissions(request, commit, *args, **kwargs):
return self.get_no_access_error(request)
tool = review_request.repository.get_scmtool()
data = tool.get_parser('').raw_diff(commit)
rsp = HttpResponse(data, content_type=mimetype)
rsp['Content-Disposition'] = ('inline; filename=%s.patch'
% commit.commit_id)
set_last_modified(rsp, commit.last_modified)
return rsp
class OriginalFileResource(WebAPIResource):
"""Provides the unpatched file corresponding to a file diff."""
name = 'original_file'
singleton = True
allowed_item_mimetypes = ['text/plain']
@webapi_check_login_required
def get(self, request, *args, **kwargs):
"""Returns the original unpatched file.
The file is returned as :mimetype:`text/plain` and is the original
file before applying a patch.
"""
try:
filediff = resources.filediff.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if filediff.is_new:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(filediff, request=request)
except Exception, e:
logging.error("Error retrieving original file: %s",
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(orig_file, mimetype='text/plain')
filename = urllib_quote(filediff.source_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
try:
orig_file = get_original_file(filediff, request=request)
except Exception, e:
logging.error("Error retrieving original file: %s",
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(orig_file,
filediff,
request=request)
except Exception, e:
logging.error("Error retrieving patched file: %s",
e,
exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, mimetype='text/plain')
filename = urllib_quote(filediff.dest_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
patched_file_resource = PatchedFileResource()
except ObjectDoesNotExist:
return DOES_NOT_EXIST
if filediff.deleted:
return DOES_NOT_EXIST
try:
orig_file = get_original_file(filediff, request=request)
except Exception, e:
logging.error("Error retrieving original file: %s", e, exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
try:
patched_file = get_patched_file(orig_file, filediff,
request=request)
except Exception, e:
logging.error("Error retrieving patched file: %s", e, exc_info=1,
request=request)
return FILE_RETRIEVAL_ERROR
resp = HttpResponse(patched_file, mimetype='text/plain')
filename = urllib_quote(filediff.dest_file)
resp['Content-Disposition'] = 'inline; filename=%s' % filename
set_last_modified(resp, filediff.diffset.timestamp)
return resp
patched_file_resource = PatchedFileResource()
# still return content for anything we have. This will prevent any
# caching.
had_error = True
context['comment_entries'].append({
'comment': comment,
'html': content,
})
page_content = render_to_string(template_name, context)
if had_error:
return HttpResponseServerError(page_content)
response = HttpResponse(page_content)
set_last_modified(response, comment.timestamp)
response['Expires'] = http_date(time.time() + 60 * 60 * 24 * 365) # 1 year
return response
@check_login_required
def diff_fragment(request, review_request_id, revision, filediff_id,
interdiff_revision=None, chunkindex=None,
template_name='diffviewer/diff_file_fragment.html'):
"""
Wrapper around diffviewer.views.view_diff_fragment that takes a review
request.
Displays just a fragment of a diff or interdiff owned by the given
review request. The fragment is identified by the chunk index in the
diff.
