# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import logging

import traceback

import tempfile

import shutil

from pylons import request, response, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.utils import jsonify, action_logger

from rhodecode.lib import diffs

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import convert_line_endings, detect_mode, safe_str,\

    str2bool

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, 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 anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

        if r_post:

            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(r_post.get('content', ''), mode)

            message = r_post.get('message') or c.default_message

            author = self.rhodecode_user.full_contact

            if content == old_content:

                h.flash(_('No changes'), category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

            try:

                self.scm_model.commit_change(repo=c.rhodecode_repo,

                                             repo_name=repo_name, cs=c.cs,

                                             user=self.rhodecode_user.user_id,

                                             author=author, message=message,

                                             content=content, f_path=f_path)

                h.flash(_('Successfully committed to %s') % f_path,

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_edit.html')

    @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 is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_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.cs = self.__get_cs_or_redirect(revision, repo_name,

                                         redirect_after=False)

class RepoGroupAssignmentError(Exception):

    pass

class NonRelativePathError(Exception):

    pass

class HTTPLockedRC(HTTPClientError):

    """

    Special Exception For locked Repos in RhodeCode, the return code can

    be overwritten by _code keyword argument passed into constructors

    """

    code = 423

    title = explanation = 'Repository Locked'

    def __init__(self, reponame, username, *args, **kwargs):

        from rhodecode import CONFIG

        from rhodecode.lib.utils2 import safe_int

        _code = CONFIG.get('lock_ret_code')

        self.code = safe_int(_code, self.code)

        self.title = self.explanation = ('Repository `%s` locked by '

                                         'user `%s`' % (reponame, username))

        super(HTTPLockedRC, self).__init__(*args, **kwargs)

from os.path import join as jn

from sqlalchemy import func

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_str, safe_unicode, get_server_url,\

    _set_extras

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny,\

    HasUserGroupPermissionAny

from rhodecode.lib.utils import get_filesystem_repos, make_ui, \

    action_logger

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

from rhodecode.lib.hooks import log_push_action

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

    """

    Cached repo list, uses in-memory cache after initialization, that is

    super fast

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        """

        Commits changes

        :param repo: SCM instance

        """

        user = self._get_user(user)

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

        imc = IMC(repo)

        imc.change(FileNode(path, content, mode=cs.get_file_mode(f_path)))

                       parents=[cs], branch=cs.branch)

        self.mark_for_invalidation(repo_name)

        self._handle_push(repo,

                          username=user.username,

                          action='push_local',

                          repo_name=repo_name,

                          revisions=[tip.raw_id])

        return tip

    def create_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Commits given multiple nodes into repo

        :param user: RhodeCode User object or user_id, the commiter

        :param repo: RhodeCode Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that commiter only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new commited changeset

        """