|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
# Copyright (C) 2010-2016 RhodeCode GmbH
|
|
|
#
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
# it under the terms of the GNU Affero General Public License, version 3
|
|
|
# (only), as published by the Free Software Foundation.
|
|
|
#
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
# GNU General Public License for more details.
|
|
|
#
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
#
|
|
|
# This program is dual-licensed. If you wish to learn more about the
|
|
|
# RhodeCode Enterprise Edition, including its added features, Support services,
|
|
|
# and proprietary license terms, please see https://rhodecode.com/licenses/
|
|
|
|
|
|
"""
|
|
|
Files controller for RhodeCode Enterprise
|
|
|
"""
|
|
|
|
|
|
import itertools
|
|
|
import logging
|
|
|
import os
|
|
|
import shutil
|
|
|
import tempfile
|
|
|
|
|
|
from pylons import request, response, tmpl_context as c, url
|
|
|
from pylons.i18n.translation import _
|
|
|
from pylons.controllers.util import redirect
|
|
|
from webob.exc import HTTPNotFound, HTTPBadRequest
|
|
|
|
|
|
from rhodecode.controllers.utils import parse_path_ref
|
|
|
from rhodecode.lib import diffs, helpers as h, caches
|
|
|
from rhodecode.lib.compat import OrderedDict
|
|
|
from rhodecode.lib.utils import jsonify, action_logger
|
|
|
from rhodecode.lib.utils2 import (
|
|
|
convert_line_endings, detect_mode, safe_str, str2bool)
|
|
|
from rhodecode.lib.auth import (
|
|
|
LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired, XHRRequired)
|
|
|
from rhodecode.lib.base import BaseRepoController, render
|
|
|
from rhodecode.lib.vcs import path as vcspath
|
|
|
from rhodecode.lib.vcs.backends.base import EmptyCommit
|
|
|
from rhodecode.lib.vcs.conf import settings
|
|
|
from rhodecode.lib.vcs.exceptions import (
|
|
|
RepositoryError, CommitDoesNotExistError, EmptyRepositoryError,
|
|
|
ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,
|
|
|
NodeDoesNotExistError, CommitError, NodeError)
|
|
|
from rhodecode.lib.vcs.nodes import FileNode
|
|
|
|
|
|
from rhodecode.model.repo import RepoModel
|
|
|
from rhodecode.model.scm import ScmModel
|
|
|
from rhodecode.model.db import Repository
|
|
|
|
|
|
from rhodecode.controllers.changeset import (
|
|
|
_ignorews_url, _context_url, get_line_ctx, get_ignore_ws)
|
|
|
from rhodecode.lib.exceptions import NonRelativePathError
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
class FilesController(BaseRepoController):
|
|
|
|
|
|
def __before__(self):
|
|
|
super(FilesController, self).__before__()
|
|
|
c.cut_off_limit = self.cut_off_limit_file
|
|
|
|
|
|
def _get_default_encoding(self):
|
|
|
enc_list = getattr(c, 'default_encodings', [])
|
|
|
return enc_list[0] if enc_list else 'UTF-8'
|
|
|
|
|
|
def __get_commit_or_redirect(self, commit_id, repo_name,
|
|
|
redirect_after=True):
|
|
|
"""
|
|
|
This is a safe way to get commit. If an error occurs it redirects to
|
|
|
tip with proper message
|
|
|
|
|
|
:param commit_id: id of commit to fetch
|
|
|
:param repo_name: repo name to redirect after
|
|
|
:param redirect_after: toggle redirection
|
|
|
"""
|
|
|
try:
|
|
|
return c.rhodecode_repo.get_commit(commit_id)
|
|
|
except EmptyRepositoryError:
|
|
|
if not redirect_after:
|
|
|
return None
|
|
|
url_ = url('files_add_home',
|
|
|
repo_name=c.repo_name,
|
|
|
revision=0, f_path='', anchor='edit')
|
|
|
if h.HasRepoPermissionAny(
|
|
|
'repository.write', 'repository.admin')(c.repo_name):
|
|
|
add_new = h.link_to(
|
|
|
_('Click here to add a new file.'),
|
|
|
url_, class_="alert-link")
|
|
|
else:
|
|
|
add_new = ""
|
|
|
h.flash(h.literal(
|
|
|
_('There are no files yet. %s') % add_new), category='warning')
|
|
|
redirect(h.url('summary_home', repo_name=repo_name))
|
|
|
except (CommitDoesNotExistError, LookupError):
|
|
|
msg = _('No such commit exists for this repository')
|
|
|
h.flash(msg, category='error')
|
|
|
raise HTTPNotFound()
|
|
|
except RepositoryError as e:
|
|
|
h.flash(safe_str(e), category='error')
|
|
|
raise HTTPNotFound()
|
|
|
|
|
|
def __get_filenode_or_redirect(self, repo_name, commit, path):
|
|
|
"""
|
|
|
Returns file_node, if error occurs or given path is directory,
|
|
|
it'll redirect to top level path
|
|
|
|
|
|
:param repo_name: repo_name
|
|
|
:param commit: given commit
|
|
|
:param path: path to lookup
|
|
|
"""
|
|
|
try:
|
|
|
file_node = commit.get_node(path)
|
|
|
if file_node.is_dir():
|
|
|
raise RepositoryError('The given path is a directory')
|
|
|
except CommitDoesNotExistError:
|
|
|
msg = _('No such commit exists for this repository')
|
|
|
log.exception(msg)
|
|
|
h.flash(msg, category='error')
|
|
|
raise HTTPNotFound()
|
|
|
except RepositoryError as e:
|
|
|
h.flash(safe_str(e), category='error')
|
|
|
raise HTTPNotFound()
|
|
|
|
|
|
return file_node
|
|
|
|
|
|
def __get_tree_cache_manager(self, repo_name, namespace_type):
|
|
|
_namespace = caches.get_repo_namespace_key(namespace_type, repo_name)
|
|
|
return caches.get_cache_manager('repo_cache_long', _namespace)
|
|
|
|
|
|
def _get_tree_at_commit(self, repo_name, commit_id, f_path,
|
|
|
full_load=False, force=False):
|
|
|
def _cached_tree():
|
|
|
log.debug('Generating cached file tree for %s, %s, %s',
|
|
|
repo_name, commit_id, f_path)
|
|
|
c.full_load = full_load
|
|
|
return render('files/files_browser_tree.html')
|
|
|
|
|
|
cache_manager = self.__get_tree_cache_manager(
|
|
|
repo_name, caches.FILE_TREE)
|
|
|
|
|
|
cache_key = caches.compute_key_from_params(
|
|
|
repo_name, commit_id, f_path)
|
|
|
|
|
|
if force:
|
|
|
# we want to force recompute of caches
|
|
|
cache_manager.remove_value(cache_key)
|
|
|
|
|
|
return cache_manager.get(cache_key, createfunc=_cached_tree)
|
|
|
|
|
|
def _get_nodelist_at_commit(self, repo_name, commit_id, f_path):
|
|
|
def _cached_nodes():
|
|
|
log.debug('Generating cached nodelist for %s, %s, %s',
|
|
|
repo_name, commit_id, f_path)
|
|
|
_d, _f = ScmModel().get_nodes(
|
|
|
repo_name, commit_id, f_path, flat=False)
|
|
|
return _d + _f
|
|
|
|
|
|
cache_manager = self.__get_tree_cache_manager(
|
|
|
repo_name, caches.FILE_SEARCH_TREE_META)
|
|
|
|
|
|
cache_key = caches.compute_key_from_params(
|
|
|
repo_name, commit_id, f_path)
|
|
|
return cache_manager.get(cache_key, createfunc=_cached_nodes)
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator(
|
|
|
'repository.read', 'repository.write', 'repository.admin')
|
|
|
def index(
|
|
|
self, repo_name, revision, f_path, annotate=False, rendered=False):
|
|
|
commit_id = revision
|
|
|
|
|
|
# redirect to given commit_id from form if given
|
|
|
get_commit_id = request.GET.get('at_rev', None)
|
|
|
if get_commit_id:
|
|
|
self.__get_commit_or_redirect(get_commit_id, repo_name)
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
c.branch = request.GET.get('branch', None)
|
|
|
c.f_path = f_path
|
|
|
c.annotate = annotate
|
|
|
# default is false, but .rst/.md files later are autorendered, we can
|
|
|
# overwrite autorendering by setting this GET flag
|
|
|
c.renderer = rendered or not request.GET.get('no-render', False)
|
|
|
|
|
|
# prev link
|
|
|
try:
|
|
|
prev_commit = c.commit.prev(c.branch)
|
|
|
c.prev_commit = prev_commit
|
|
|
c.url_prev = url('files_home', repo_name=c.repo_name,
|
|
|
revision=prev_commit.raw_id, f_path=f_path)
|
|
|
if c.branch:
|
|
|
c.url_prev += '?branch=%s' % c.branch
|
|
|
except (CommitDoesNotExistError, VCSError):
|
|
|
c.url_prev = '#'
|
|
|
c.prev_commit = EmptyCommit()
|
|
|
|
|
|
# next link
|
|
|
try:
|
|
|
next_commit = c.commit.next(c.branch)
|
|
|
c.next_commit = next_commit
|
|
|
c.url_next = url('files_home', repo_name=c.repo_name,
|
|
|
revision=next_commit.raw_id, f_path=f_path)
|
|
|
if c.branch:
|
|
|
c.url_next += '?branch=%s' % c.branch
|
|
|
except (CommitDoesNotExistError, VCSError):
|
|
|
c.url_next = '#'
|
|
|
c.next_commit = EmptyCommit()
|
|
|
|
|
|
# files or dirs
|
|
|
try:
|
|
|
c.file = c.commit.get_node(f_path)
|
|
|
c.file_author = True
|
|
|
c.file_tree = ''
|
|
|
if c.file.is_file():
|
|
|
c.renderer = (
|
|
|
c.renderer and h.renderer_from_filename(c.file.path))
|
|
|
c.file_last_commit = c.file.last_commit
|
|
|
|
|
|
c.on_branch_head = self._is_valid_head(
|
|
|
commit_id, c.rhodecode_repo)
|
|
|
c.branch_or_raw_id = c.commit.branch or c.commit.raw_id
|
|
|
|
|
|
author = c.file_last_commit.author
|
|
|
c.authors = [(h.email(author),
|
|
|
h.person(author, 'username_or_name_or_email'))]
|
|
|
else:
|
|
|
c.authors = []
|
|
|
c.file_tree = self._get_tree_at_commit(
|
|
|
repo_name, c.commit.raw_id, f_path)
|
|
|
|
|
|
except RepositoryError as e:
|
|
|
h.flash(safe_str(e), category='error')
|
|
|
raise HTTPNotFound()
|
|
|
|
|
|
if request.environ.get('HTTP_X_PJAX'):
|
|
|
return render('files/files_pjax.html')
|
|
|
|
|
|
return render('files/files.html')
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
@jsonify
|
|
|
def history(self, repo_name, revision, f_path):
|
|
|
commit = self.__get_commit_or_redirect(revision, repo_name)
|
|
|
f_path = f_path
|
|
|
_file = commit.get_node(f_path)
|
|
|
if _file.is_file():
|
|
|
file_history, _hist = self._get_node_history(commit, f_path)
|
|
|
|
|
|
res = []
|
|
|
for obj in file_history:
|
|
|
res.append({
|
|
|
'text': obj[1],
|
|
|
'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]
|
|
|
})
|
|
|
|
|
|
data = {
|
|
|
'more': False,
|
|
|
'results': res
|
|
|
}
|
|
|
return data
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def authors(self, repo_name, revision, f_path):
|
|
|
commit = self.__get_commit_or_redirect(revision, repo_name)
|
|
|
file_node = commit.get_node(f_path)
|
|
|
if file_node.is_file():
|
|
|
c.file_last_commit = file_node.last_commit
|
|
|
if request.GET.get('annotate') == '1':
|
|
|
# use _hist from annotation if annotation mode is on
|
|
|
commit_ids = set(x[1] for x in file_node.annotate)
|
|
|
_hist = (
|
|
|
c.rhodecode_repo.get_commit(commit_id)
|
|
|
for commit_id in commit_ids)
|
|
|
else:
|
|
|
_f_history, _hist = self._get_node_history(commit, f_path)
|
|
|
c.file_author = False
|
|
|
c.authors = []
|
|
|
for author in set(commit.author for commit in _hist):
|
|
|
c.authors.append((
|
|
|
h.email(author),
|
|
|
h.person(author, 'username_or_name_or_email')))
|
|
|
return render('files/file_authors_box.html')
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def rawfile(self, repo_name, revision, f_path):
|
|
|
"""
|
|
|
Action for download as raw
|
|
|
"""
|
|
|
commit = self.__get_commit_or_redirect(revision, repo_name)
|
|
|
file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
|
|
|
|
|
|
response.content_disposition = 'attachment; filename=%s' % \
|
|
|
safe_str(f_path.split(Repository.NAME_SEP)[-1])
|
|
|
|
|
|
response.content_type = file_node.mimetype
|
|
|
charset = self._get_default_encoding()
|
|
|
if charset:
|
|
|
response.charset = charset
|
|
|
|
|
|
return file_node.content
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def raw(self, repo_name, revision, f_path):
|
|
|
"""
|
|
|
Action for show as raw, some mimetypes are "rendered",
|
|
|
those include images, icons.
|
|
|
"""
|
|
|
commit = self.__get_commit_or_redirect(revision, repo_name)
|
|
|
file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
|
|
|
|
|
|
raw_mimetype_mapping = {
|
|
|
# map original mimetype to a mimetype used for "show as raw"
|
|
|
# you can also provide a content-disposition to override the
|
|
|
# default "attachment" disposition.
|
|
|
# orig_type: (new_type, new_dispo)
|
|
|
|
|
|
# show images inline:
|
|
|
# Do not re-add SVG: it is unsafe and permits XSS attacks. One can
|
|
|
# for example render an SVG with javascript inside or even render
|
|
|
# HTML.
|
|
|
'image/x-icon': ('image/x-icon', 'inline'),
|
|
|
'image/png': ('image/png', 'inline'),
|
|
|
'image/gif': ('image/gif', 'inline'),
|
|
|
'image/jpeg': ('image/jpeg', 'inline'),
|
|
|
}
|
|
|
|
|
|
mimetype = file_node.mimetype
|
|
|
try:
|
|
|
mimetype, dispo = raw_mimetype_mapping[mimetype]
|
|
|
except KeyError:
|
|
|
# we don't know anything special about this, handle it safely
|
|
|
if file_node.is_binary:
|
|
|
# do same as download raw for binary files
|
|
|
mimetype, dispo = 'application/octet-stream', 'attachment'
|
|
|
else:
|
|
|
# do not just use the original mimetype, but force text/plain,
|
|
|
# otherwise it would serve text/html and that might be unsafe.
|
|
|
# Note: underlying vcs library fakes text/plain mimetype if the
|
|
|
# mimetype can not be determined and it thinks it is not
|
|
|
# binary.This might lead to erroneous text display in some
|
|
|
# cases, but helps in other cases, like with text files
|
|
|
# without extension.
|
|
|
mimetype, dispo = 'text/plain', 'inline'
|
|
|
|
|
|
if dispo == 'attachment':
|
|
|
dispo = 'attachment; filename=%s' % safe_str(
|
|
|
f_path.split(os.sep)[-1])
|
|
|
|
|
|
response.content_disposition = dispo
|
|
|
response.content_type = mimetype
|
|
|
charset = self._get_default_encoding()
|
|
|
if charset:
|
|
|
response.charset = charset
|
|
|
return file_node.content
|
|
|
|
|
|
@CSRFRequired()
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def delete(self, repo_name, revision, f_path):
|
|
|
commit_id = revision
|
|
|
|
|
|
repo = c.rhodecode_db_repo
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
if not self._is_valid_head(commit_id, repo.scm_instance()):
|
|
|
h.flash(_('You can only delete files with revision '
|
|
|
'being a valid branch '), category='warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip',
|
|
|
f_path=f_path))
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
|
|
|
|
|
|
c.default_message = _(
|
|
|
'Deleted file %s via RhodeCode Enterprise') % (f_path)
|
|
|
c.f_path = f_path
|
|
|
node_path = f_path
|
|
|
author = c.rhodecode_user.full_contact
|
|
|
message = request.POST.get('message') or c.default_message
|
|
|
try:
|
|
|
nodes = {
|
|
|
node_path: {
|
|
|
'content': ''
|
|
|
}
|
|
|
}
|
|
|
self.scm_model.delete_nodes(
|
|
|
user=c.rhodecode_user.user_id, repo=c.rhodecode_db_repo,
|
|
|
message=message,
|
|
|
nodes=nodes,
|
|
|
parent_commit=c.commit,
|
|
|
author=author,
|
|
|
)
|
|
|
|
|
|
h.flash(_('Successfully deleted file %s') % f_path,
|
|
|
category='success')
|
|
|
except Exception:
|
|
|
msg = _('Error occurred during commit')
|
|
|
log.exception(msg)
|
|
|
h.flash(msg, category='error')
|
|
|
return redirect(url('changeset_home',
|
|
|
repo_name=c.repo_name, revision='tip'))
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def delete_home(self, repo_name, revision, f_path):
|
|
|
commit_id = revision
|
|
|
|
|
|
repo = c.rhodecode_db_repo
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
if not self._is_valid_head(commit_id, repo.scm_instance()):
|
|
|
h.flash(_('You can only delete files with revision '
|
|
|
'being a valid branch '), category='warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip',
|
|
|
f_path=f_path))
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
|
|
|
|
|
|
c.default_message = _(
|
|
|
'Deleted file %s via RhodeCode Enterprise') % (f_path)
|
|
|
c.f_path = f_path
|
|
|
|
|
|
return render('files/files_delete.html')
|
|
|
|
|
|
@CSRFRequired()
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def edit(self, repo_name, revision, f_path):
|
|
|
commit_id = revision
|
|
|
|
|
|
repo = c.rhodecode_db_repo
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
if not self._is_valid_head(commit_id, repo.scm_instance()):
|
|
|
h.flash(_('You can only edit files with revision '
|
|
|
'being a valid branch '), category='warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip',
|
|
|
f_path=f_path))
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
|
|
|
|
|
|
if c.file.is_binary:
|
|
|
return redirect(url('files_home', repo_name=c.repo_name,
|
|
|
revision=c.commit.raw_id, f_path=f_path))
|
|
|
c.default_message = _(
|
|
|
'Edited file %s via RhodeCode Enterprise') % (f_path)
|
|
|
c.f_path = f_path
|
|
|
old_content = c.file.content
|
|
|
sl = old_content.splitlines(1)
|
|
|
first_line = sl[0] if sl else ''
|
|
|
|
|
|
# modes: 0 - Unix, 1 - Mac, 2 - DOS
|
|
|
mode = detect_mode(first_line, 0)
|
|
|
content = convert_line_endings(request.POST.get('content', ''), mode)
|
|
|
|
|
|
message = request.POST.get('message') or c.default_message
|
|
|
org_f_path = c.file.unicode_path
|
|
|
filename = request.POST['filename']
|
|
|
org_filename = c.file.name
|
|
|
|
|
|
if content == old_content and filename == org_filename:
|
|
|
h.flash(_('No changes'), category='warning')
|
|
|
return redirect(url('changeset_home', repo_name=c.repo_name,
|
|
|
revision='tip'))
|
|
|
try:
|
|
|
mapping = {
|
|
|
org_f_path: {
|
|
|
'org_filename': org_f_path,
|
|
|
'filename': os.path.join(c.file.dir_path, filename),
|
|
|
'content': content,
|
|
|
'lexer': '',
|
|
|
'op': 'mod',
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ScmModel().update_nodes(
|
|
|
user=c.rhodecode_user.user_id,
|
|
|
repo=c.rhodecode_db_repo,
|
|
|
message=message,
|
|
|
nodes=mapping,
|
|
|
parent_commit=c.commit,
|
|
|
)
|
|
|
|
|
|
h.flash(_('Successfully committed to %s') % f_path,
|
|
|
category='success')
|
|
|
except Exception:
|
|
|
msg = _('Error occurred during commit')
|
|
|
log.exception(msg)
|
|
|
h.flash(msg, category='error')
|
|
|
return redirect(url('changeset_home',
|
|
|
repo_name=c.repo_name, revision='tip'))
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def edit_home(self, repo_name, revision, f_path):
|
|
|
commit_id = revision
|
|
|
|
|
|
repo = c.rhodecode_db_repo
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
if not self._is_valid_head(commit_id, repo.scm_instance()):
|
|
|
h.flash(_('You can only edit files with revision '
|
|
|
'being a valid branch '), category='warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip',
|
|
|
f_path=f_path))
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
|
|
|
|
|
|
if c.file.is_binary:
|
|
|
return redirect(url('files_home', repo_name=c.repo_name,
|
|
|
revision=c.commit.raw_id, f_path=f_path))
|
|
|
c.default_message = _(
|
|
|
'Edited file %s via RhodeCode Enterprise') % (f_path)
|
|
|
c.f_path = f_path
|
|
|
|
|
|
return render('files/files_edit.html')
|
|
|
|
|
|
def _is_valid_head(self, commit_id, repo):
|
|
|
# check if commit is a branch identifier- basically we cannot
|
|
|
# create multiple heads via file editing
|
|
|
valid_heads = repo.branches.keys() + repo.branches.values()
|
|
|
|
|
|
if h.is_svn(repo) and not repo.is_empty():
|
|
|
# Note: Subversion only has one head, we add it here in case there
|
|
|
# is no branch matched.
|
|
|
valid_heads.append(repo.get_commit(commit_idx=-1).raw_id)
|
|
|
|
|
|
# check if commit is a branch name or branch hash
|
|
|
return commit_id in valid_heads
|
|
|
|
|
|
@CSRFRequired()
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def add(self, repo_name, revision, f_path):
|
|
|
repo = Repository.get_by_repo_name(repo_name)
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
r_post = request.POST
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(
|
|
|
revision, repo_name, redirect_after=False)
|
|
|
if c.commit is None:
|
|
|
c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
|
|
|
c.default_message = (_('Added file via RhodeCode Enterprise'))
|
|
|
c.f_path = f_path
|
|
|
unix_mode = 0
|
|
|
content = convert_line_endings(r_post.get('content', ''), unix_mode)
|
|
|
|
|
|
message = r_post.get('message') or c.default_message
|
|
|
filename = r_post.get('filename')
|
|
|
location = r_post.get('location', '') # dir location
|
|
|
file_obj = r_post.get('upload_file', None)
|
|
|
|
|
|
if file_obj is not None and hasattr(file_obj, 'filename'):
|
|
|
filename = file_obj.filename
|
|
|
content = file_obj.file
|
|
|
|
|
|
if hasattr(content, 'file'):
|
|
|
# non posix systems store real file under file attr
|
|
|
content = content.file
|
|
|
|
|
|
# If there's no commit, redirect to repo summary
|
|
|
if type(c.commit) is EmptyCommit:
|
|
|
redirect_url = "summary_home"
|
|
|
else:
|
|
|
redirect_url = "changeset_home"
|
|
|
|
|
|
if not filename:
|
|
|
h.flash(_('No filename'), category='warning')
|
|
|
return redirect(url(redirect_url, repo_name=c.repo_name,
|
|
|
revision='tip'))
|
|
|
|
|
|
# extract the location from filename,
|
|
|
# allows using foo/bar.txt syntax to create subdirectories
|
|
|
subdir_loc = filename.rsplit('/', 1)
|
|
|
if len(subdir_loc) == 2:
|
|
|
location = os.path.join(location, subdir_loc[0])
|
|
|
|
|
|
# strip all crap out of file, just leave the basename
|
|
|
filename = os.path.basename(filename)
|
|
|
node_path = os.path.join(location, filename)
|
|
|
author = c.rhodecode_user.full_contact
|
|
|
|
|
|
try:
|
|
|
nodes = {
|
|
|
node_path: {
|
|
|
'content': content
|
|
|
}
|
|
|
}
|
|
|
self.scm_model.create_nodes(
|
|
|
user=c.rhodecode_user.user_id,
|
|
|
repo=c.rhodecode_db_repo,
|
|
|
message=message,
|
|
|
nodes=nodes,
|
|
|
parent_commit=c.commit,
|
|
|
author=author,
|
|
|
)
|
|
|
|
|
|
h.flash(_('Successfully committed to %s') % node_path,
|
|
|
category='success')
|
|
|
except NonRelativePathError as e:
|
|
|
h.flash(_(
|
|
|
'The location specified must be a relative path and must not '
|
|
|
'contain .. in the path'), category='warning')
|
|
|
return redirect(url('changeset_home', repo_name=c.repo_name,
|
|
|
revision='tip'))
|
|
|
except (NodeError, NodeAlreadyExistsError) as e:
|
|
|
h.flash(_(e), category='error')
|
|
|
except Exception:
|
|
|
msg = _('Error occurred during commit')
|
|
|
log.exception(msg)
|
|
|
h.flash(msg, category='error')
|
|
|
return redirect(url('changeset_home',
|
|
|
repo_name=c.repo_name, revision='tip'))
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
|
|
|
def add_home(self, repo_name, revision, f_path):
|
|
|
|
|
|
repo = Repository.get_by_repo_name(repo_name)
|
|
|
if repo.enable_locking and repo.locked[0]:
|
|
|
h.flash(_('This repository has been locked by %s on %s')
|
|
|
% (h.person_by_id(repo.locked[0]),
|
|
|
h.format_date(h.time_to_datetime(repo.locked[1]))),
|
|
|
'warning')
|
|
|
return redirect(h.url('files_home',
|
|
|
repo_name=repo_name, revision='tip'))
|
|
|
|
|
|
c.commit = self.__get_commit_or_redirect(
|
|
|
revision, repo_name, redirect_after=False)
|
|
|
if c.commit is None:
|
|
|
c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
|
|
|
c.default_message = (_('Added file via RhodeCode Enterprise'))
|
|
|
c.f_path = f_path
|
|
|
|
|
|
return render('files/files_add.html')
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def archivefile(self, repo_name, fname):
|
|
|
fileformat = None
|
|
|
commit_id = None
|
|
|
ext = None
|
|
|
subrepos = request.GET.get('subrepos') == 'true'
|
|
|
|
|
|
for a_type, ext_data in settings.ARCHIVE_SPECS.items():
|
|
|
archive_spec = fname.split(ext_data[1])
|
|
|
if len(archive_spec) == 2 and archive_spec[1] == '':
|
|
|
fileformat = a_type or ext_data[1]
|
|
|
commit_id = archive_spec[0]
|
|
|
ext = ext_data[1]
|
|
|
|
|
|
dbrepo = RepoModel().get_by_repo_name(repo_name)
|
|
|
if not dbrepo.enable_downloads:
|
|
|
return _('Downloads disabled')
|
|
|
|
|
|
try:
|
|
|
commit = c.rhodecode_repo.get_commit(commit_id)
|
|
|
content_type = settings.ARCHIVE_SPECS[fileformat][0]
|
|
|
except CommitDoesNotExistError:
|
|
|
return _('Unknown revision %s') % commit_id
|
|
|
except EmptyRepositoryError:
|
|
|
return _('Empty repository')
|
|
|
except KeyError:
|
|
|
return _('Unknown archive type')
|
|
|
|
|
|
# archive cache
|
|
|
from rhodecode import CONFIG
|
|
|
|
|
|
archive_name = '%s-%s%s%s' % (
|
|
|
safe_str(repo_name.replace('/', '_')),
|
|
|
'-sub' if subrepos else '',
|
|
|
safe_str(commit.short_id), ext)
|
|
|
|
|
|
use_cached_archive = False
|
|
|
archive_cache_enabled = CONFIG.get(
|
|
|
'archive_cache_dir') and not request.GET.get('no_cache')
|
|
|
|
|
|
if archive_cache_enabled:
|
|
|
# check if we it's ok to write
|
|
|
if not os.path.isdir(CONFIG['archive_cache_dir']):
|
|
|
os.makedirs(CONFIG['archive_cache_dir'])
|
|
|
cached_archive_path = os.path.join(
|
|
|
CONFIG['archive_cache_dir'], archive_name)
|
|
|
if os.path.isfile(cached_archive_path):
|
|
|
log.debug('Found cached archive in %s', cached_archive_path)
|
|
|
fd, archive = None, cached_archive_path
|
|
|
use_cached_archive = True
|
|
|
else:
|
|
|
log.debug('Archive %s is not yet cached', archive_name)
|
|
|
|
|
|
if not use_cached_archive:
|
|
|
# generate new archive
|
|
|
fd, archive = tempfile.mkstemp()
|
|
|
log.debug('Creating new temp archive in %s' % (archive,))
|
|
|
try:
|
|
|
commit.archive_repo(archive, kind=fileformat, subrepos=subrepos)
|
|
|
except ImproperArchiveTypeError:
|
|
|
return _('Unknown archive type')
|
|
|
if archive_cache_enabled:
|
|
|
# if we generated the archive and we have cache enabled
|
|
|
# let's use this for future
|
|
|
log.debug('Storing new archive in %s' % (cached_archive_path,))
|
|
|
shutil.move(archive, cached_archive_path)
|
|
|
archive = cached_archive_path
|
|
|
|
|
|
def get_chunked_archive(archive):
|
|
|
with open(archive, 'rb') as stream:
|
|
|
while True:
|
|
|
data = stream.read(16 * 1024)
|
|
|
if not data:
|
|
|
if fd: # fd means we used temporary file
|
|
|
os.close(fd)
|
|
|
if not archive_cache_enabled:
|
|
|
log.debug('Destroying temp archive %s', archive)
|
|
|
os.remove(archive)
|
|
|
break
|
|
|
yield data
|
|
|
|
|
|
# store download action
|
|
|
action_logger(user=c.rhodecode_user,
|
|
|
action='user_downloaded_archive:%s' % archive_name,
|
|
|
repo=repo_name, ipaddr=self.ip_addr, commit=True)
|
|
|
response.content_disposition = str(
|
|
|
'attachment; filename=%s' % archive_name)
|
|
|
response.content_type = str(content_type)
|
|
|
|
|
|
return get_chunked_archive(archive)
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def diff(self, repo_name, f_path):
|
|
|
ignore_whitespace = request.GET.get('ignorews') == '1'
|
|
|
line_context = request.GET.get('context', 3)
|
|
|
diff1 = request.GET.get('diff1', '')
|
|
|
|
|
|
path1, diff1 = parse_path_ref(diff1, default_path=f_path)
|
|
|
|
|
|
diff2 = request.GET.get('diff2', '')
|
|
|
c.action = request.GET.get('diff')
|
|
|
c.no_changes = diff1 == diff2
|
|
|
c.f_path = f_path
|
|
|
c.big_diff = False
|
|
|
c.ignorews_url = _ignorews_url
|
|
|
c.context_url = _context_url
|
|
|
c.changes = OrderedDict()
|
|
|
c.changes[diff2] = []
|
|
|
|
|
|
if not any((diff1, diff2)):
|
|
|
h.flash(
|
|
|
'Need query parameter "diff1" or "diff2" to generate a diff.',
|
|
|
category='error')
|
|
|
raise HTTPBadRequest()
|
|
|
|
|
|
# special case if we want a show commit_id only, it's impl here
|
|
|
# to reduce JS and callbacks
|
|
|
|
|
|
if request.GET.get('show_rev') and diff1:
|
|
|
if str2bool(request.GET.get('annotate', 'False')):
|
|
|
_url = url('files_annotate_home', repo_name=c.repo_name,
|
|
|
revision=diff1, f_path=path1)
|
|
|
else:
|
|
|
_url = url('files_home', repo_name=c.repo_name,
|
|
|
revision=diff1, f_path=path1)
|
|
|
|
|
|
return redirect(_url)
|
|
|
|
|
|
try:
|
|
|
node1 = self._get_file_node(diff1, path1)
|
|
|
node2 = self._get_file_node(diff2, f_path)
|
|
|
except (RepositoryError, NodeError):
|
|
|
log.exception("Exception while trying to get node from repository")
|
|
|
return redirect(url(
|
|
|
'files_home', repo_name=c.repo_name, f_path=f_path))
|
|
|
|
|
|
if all(isinstance(node.commit, EmptyCommit)
|
|
|
for node in (node1, node2)):
|
|
|
raise HTTPNotFound
|
|
|
|
|
|
c.commit_1 = node1.commit
|
|
|
c.commit_2 = node2.commit
|
|
|
|
|
|
if c.action == 'download':
|
|
|
_diff = diffs.get_gitdiff(node1, node2,
|
|
|
ignore_whitespace=ignore_whitespace,
|
|
|
context=line_context)
|
|
|
diff = diffs.DiffProcessor(_diff, format='gitdiff')
|
|
|
|
|
|
diff_name = '%s_vs_%s.diff' % (diff1, diff2)
|
|
|
response.content_type = 'text/plain'
|
|
|
response.content_disposition = (
|
|
|
'attachment; filename=%s' % (diff_name,)
|
|
|
)
|
|
|
charset = self._get_default_encoding()
|
|
|
if charset:
|
|
|
response.charset = charset
|
|
|
return diff.as_raw()
|
|
|
|
|
|
elif c.action == 'raw':
|
|
|
_diff = diffs.get_gitdiff(node1, node2,
|
|
|
ignore_whitespace=ignore_whitespace,
|
|
|
context=line_context)
|
|
|
diff = diffs.DiffProcessor(_diff, format='gitdiff')
|
|
|
response.content_type = 'text/plain'
|
|
|
charset = self._get_default_encoding()
|
|
|
if charset:
|
|
|
response.charset = charset
|
|
|
return diff.as_raw()
|
|
|
|
|
|
else:
|
|
|
fid = h.FID(diff2, node2.path)
|
|
|
line_context_lcl = get_line_ctx(fid, request.GET)
|
|
|
ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
|
|
|
|
|
|
__, commit1, commit2, diff, st, data = diffs.wrapped_diff(
|
|
|
filenode_old=node1,
|
|
|
filenode_new=node2,
|
|
|
diff_limit=self.cut_off_limit_diff,
|
|
|
file_limit=self.cut_off_limit_file,
|
|
|
show_full_diff=request.GET.get('fulldiff'),
|
|
|
ignore_whitespace=ign_whitespace_lcl,
|
|
|
line_context=line_context_lcl,)
|
|
|
|
|
|
c.lines_added = data['stats']['added'] if data else 0
|
|
|
c.lines_deleted = data['stats']['deleted'] if data else 0
|
|
|
c.files = [data]
|
|
|
c.commit_ranges = [c.commit_1, c.commit_2]
|
|
|
c.ancestor = None
|
|
|
c.statuses = []
|
|
|
c.target_repo = c.rhodecode_db_repo
|
|
|
c.filename1 = node1.path
|
|
|
c.filename = node2.path
|
|
|
c.binary_file = node1.is_binary or node2.is_binary
|
|
|
operation = data['operation'] if data else ''
|
|
|
|
|
|
commit_changes = {
|
|
|
# TODO: it's passing the old file to the diff to keep the
|
|
|
# standard but this is not being used for this template,
|
|
|
# but might need both files in the future or a more standard
|
|
|
# way to work with that
|
|
|
'fid': [commit1, commit2, operation,
|
|
|
c.filename, diff, st, data]
|
|
|
}
|
|
|
|
|
|
c.changes = commit_changes
|
|
|
|
|
|
return render('files/file_diff.html')
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
|
|
|
'repository.admin')
|
|
|
def diff_2way(self, repo_name, f_path):
|
|
|
diff1 = request.GET.get('diff1', '')
|
|
|
diff2 = request.GET.get('diff2', '')
|
|
|
|
|
|
nodes = []
|
|
|
unknown_commits = []
|
|
|
for commit in [diff1, diff2]:
|
|
|
try:
|
|
|
nodes.append(self._get_file_node(commit, f_path))
|
|
|
except (RepositoryError, NodeError):
|
|
|
log.exception('%(commit)s does not exist' % {'commit': commit})
|
|
|
unknown_commits.append(commit)
|
|
|
h.flash(h.literal(
|
|
|
_('Commit %(commit)s does not exist.') % {'commit': commit}
|
|
|
), category='error')
|
|
|
|
|
|
if unknown_commits:
|
|
|
return redirect(url('files_home', repo_name=c.repo_name,
|
|
|
f_path=f_path))
|
|
|
|
|
|
if all(isinstance(node.commit, EmptyCommit) for node in nodes):
|
|
|
raise HTTPNotFound
|
|
|
|
|
|
node1, node2 = nodes
|
|
|
|
|
|
f_gitdiff = diffs.get_gitdiff(node1, node2, ignore_whitespace=False)
|
|
|
diff_processor = diffs.DiffProcessor(f_gitdiff, format='gitdiff')
|
|
|
diff_data = diff_processor.prepare()
|
|
|
|
|
|
if not diff_data or diff_data[0]['raw_diff'] == '':
|
|
|
h.flash(h.literal(_('%(file_path)s has not changed '
|
|
|
'between %(commit_1)s and %(commit_2)s.') % {
|
|
|
'file_path': f_path,
|
|
|
'commit_1': node1.commit.id,
|
|
|
'commit_2': node2.commit.id
|
|
|
}), category='error')
|
|
|
return redirect(url('files_home', repo_name=c.repo_name,
|
|
|
f_path=f_path))
|
|
|
|
|
|
c.diff_data = diff_data[0]
|
|
|
c.FID = h.FID(diff2, node2.path)
|
|
|
# cleanup some unneeded data
|
|
|
del c.diff_data['raw_diff']
|
|
|
del c.diff_data['chunks']
|
|
|
|
|
|
c.node1 = node1
|
|
|
c.commit_1 = node1.commit
|
|
|
c.node2 = node2
|
|
|
c.commit_2 = node2.commit
|
|
|
|
|
|
return render('files/diff_2way.html')
|
|
|
|
|
|
def _get_file_node(self, commit_id, f_path):
|
|
|
if commit_id not in ['', None, 'None', '0' * 12, '0' * 40]:
|
|
|
commit = c.rhodecode_repo.get_commit(commit_id=commit_id)
|
|
|
try:
|
|
|
node = commit.get_node(f_path)
|
|
|
if node.is_dir():
|
|
|
raise NodeError('%s path is a %s not a file'
|
|
|
% (node, type(node)))
|
|
|
except NodeDoesNotExistError:
|
|
|
commit = EmptyCommit(
|
|
|
commit_id=commit_id,
|
|
|
idx=commit.idx,
|
|
|
repo=commit.repository,
|
|
|
alias=commit.repository.alias,
|
|
|
message=commit.message,
|
|
|
author=commit.author,
|
|
|
date=commit.date)
|
|
|
node = FileNode(f_path, '', commit=commit)
|
|
|
else:
|
|
|
commit = EmptyCommit(
|
|
|
repo=c.rhodecode_repo,
|
|
|
alias=c.rhodecode_repo.alias)
|
|
|
node = FileNode(f_path, '', commit=commit)
|
|
|
return node
|
|
|
|
|
|
def _get_node_history(self, commit, f_path, commits=None):
|
|
|
"""
|
|
|
get commit history for given node
|
|
|
|
|
|
:param commit: commit to calculate history
|
|
|
:param f_path: path for node to calculate history for
|
|
|
:param commits: if passed don't calculate history and take
|
|
|
commits defined in this list
|
|
|
"""
|
|
|
# calculate history based on tip
|
|
|
tip = c.rhodecode_repo.get_commit()
|
|
|
if commits is None:
|
|
|
pre_load = ["author", "branch"]
|
|
|
try:
|
|
|
commits = tip.get_file_history(f_path, pre_load=pre_load)
|
|
|
except (NodeDoesNotExistError, CommitError):
|
|
|
# this node is not present at tip!
|
|
|
commits = commit.get_file_history(f_path, pre_load=pre_load)
|
|
|
|
|
|
history = []
|
|
|
commits_group = ([], _("Changesets"))
|
|
|
for commit in commits:
|
|
|
branch = ' (%s)' % commit.branch if commit.branch else ''
|
|
|
n_desc = 'r%s:%s%s' % (commit.idx, commit.short_id, branch)
|
|
|
commits_group[0].append((commit.raw_id, n_desc,))
|
|
|
history.append(commits_group)
|
|
|
|
|
|
symbolic_reference = self._symbolic_reference
|
|
|
|
|
|
if c.rhodecode_repo.alias == 'svn':
|
|
|
adjusted_f_path = self._adjust_file_path_for_svn(
|
|
|
f_path, c.rhodecode_repo)
|
|
|
if adjusted_f_path != f_path:
|
|
|
log.debug(
|
|
|
'Recognized svn tag or branch in file "%s", using svn '
|
|
|
'specific symbolic references', f_path)
|
|
|
f_path = adjusted_f_path
|
|
|
symbolic_reference = self._symbolic_reference_svn
|
|
|
|
|
|
branches = self._create_references(
|
|
|
c.rhodecode_repo.branches, symbolic_reference, f_path)
|
|
|
branches_group = (branches, _("Branches"))
|
|
|
|
|
|
tags = self._create_references(
|
|
|
c.rhodecode_repo.tags, symbolic_reference, f_path)
|
|
|
tags_group = (tags, _("Tags"))
|
|
|
|
|
|
history.append(branches_group)
|
|
|
history.append(tags_group)
|
|
|
|
|
|
return history, commits
|
|
|
|
|
|
def _adjust_file_path_for_svn(self, f_path, repo):
|
|
|
"""
|
|
|
Computes the relative path of `f_path`.
|
|
|
|
|
|
This is mainly based on prefix matching of the recognized tags and
|
|
|
branches in the underlying repository.
|
|
|
"""
|
|
|
tags_and_branches = itertools.chain(
|
|
|
repo.branches.iterkeys(),
|
|
|
repo.tags.iterkeys())
|
|
|
tags_and_branches = sorted(tags_and_branches, key=len, reverse=True)
|
|
|
|
|
|
for name in tags_and_branches:
|
|
|
if f_path.startswith(name + '/'):
|
|
|
f_path = vcspath.relpath(f_path, name)
|
|
|
break
|
|
|
return f_path
|
|
|
|
|
|
def _create_references(
|
|
|
self, branches_or_tags, symbolic_reference, f_path):
|
|
|
items = []
|
|
|
for name, commit_id in branches_or_tags.items():
|
|
|
sym_ref = symbolic_reference(commit_id, name, f_path)
|
|
|
items.append((sym_ref, name))
|
|
|
return items
|
|
|
|
|
|
def _symbolic_reference(self, commit_id, name, f_path):
|
|
|
return commit_id
|
|
|
|
|
|
def _symbolic_reference_svn(self, commit_id, name, f_path):
|
|
|
new_f_path = vcspath.join(name, f_path)
|
|
|
return u'%s@%s' % (new_f_path, commit_id)
|
|
|
|
|
|
@LoginRequired()
|
|
|
@XHRRequired()
|
|
|
@HasRepoPermissionAnyDecorator(
|
|
|
'repository.read', 'repository.write', 'repository.admin')
|
|
|
@jsonify
|
|
|
def nodelist(self, repo_name, revision, f_path):
|
|
|
commit = self.__get_commit_or_redirect(revision, repo_name)
|
|
|
|
|
|
metadata = self._get_nodelist_at_commit(
|
|
|
repo_name, commit.raw_id, f_path)
|
|
|
return {'nodes': metadata}
|
|
|
|
|
|
@LoginRequired()
|
|
|
@XHRRequired()
|
|
|
@HasRepoPermissionAnyDecorator(
|
|
|
'repository.read', 'repository.write', 'repository.admin')
|
|
|
def nodetree_full(self, repo_name, commit_id, f_path):
|
|
|
"""
|
|
|
Returns rendered html of file tree that contains commit date,
|
|
|
author, revision for the specified combination of
|
|
|
repo, commit_id and file path
|
|
|
|
|
|
:param repo_name: name of the repository
|
|
|
:param commit_id: commit_id of file tree
|
|
|
:param f_path: file path of the requested directory
|
|
|
"""
|
|
|
|
|
|
commit = self.__get_commit_or_redirect(commit_id, repo_name)
|
|
|
try:
|
|
|
dir_node = commit.get_node(f_path)
|
|
|
except RepositoryError as e:
|
|
|
return 'error {}'.format(safe_str(e))
|
|
|
|
|
|
if dir_node.is_file():
|
|
|
return ''
|
|
|
|
|
|
c.file = dir_node
|
|
|
c.commit = commit
|
|
|
|
|
|
# using force=True here, make a little trick. We flush the cache and
|
|
|
# compute it using the same key as without full_load, so the fully
|
|
|
# loaded cached tree is now returned instead of partial
|
|
|
return self._get_tree_at_commit(
|
|
|
repo_name, commit.raw_id, dir_node.path, full_load=True,
|
|
|
force=True)
|
|
|
|
