try:

            ScmModel().mark_for_invalidation(repo_name)

            Session().commit()

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during cache invalidation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def repo_locking(self, repo_name):

        """

        Unlock repository when it is locked !

        :param repo_name:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if request.POST.get('set_lock'):

                Repository.lock(repo, c.rhodecode_user.user_id)

            elif request.POST.get('set_unlock'):

                Repository.unlock(repo)

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def toggle_locking(self, repo_name):

        """

        Toggle locking of repository by simple GET call to url

        :param repo_name:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if repo.enable_locking:

                if repo.locked[0]:

                    Repository.unlock(repo)

                    action = _('Unlocked')

                else:

                    Repository.lock(repo, c.rhodecode_user.user_id)

                    action = _('Locked')

                h.flash(_('Repository has been %s') % action,

                        category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

        return redirect(url('summary_home', repo_name=repo_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def repo_public_journal(self, repo_name):

        """

        Set's this repository to be visible in public journal,

        in other words assing default user to follow this repo

        :param repo_name:

        """

        cur_token = request.POST.get('auth_token')

        token = get_token()

        if cur_token == token:

            try:

                repo_id = Repository.get_by_repo_name(repo_name).repo_id

                user_id = User.get_default_user().user_id

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

                Session().commit()

            except Exception:

                h.flash(_('An error occurred during setting this'

                          ' repository in public journal'),

                        category='error')

        else:

            h.flash(_('Token mismatch'), category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def repo_pull(self, repo_name):

        """

        Runs task to update given repository with remote changes,

        ie. make pull on remote location

        :param repo_name:

        """

        try:

            ScmModel().pull_changes(repo_name, self.rhodecode_user.username)

            h.flash(_('Pulled from remote location'), category='success')

        except Exception, e:

            h.flash(_('An error occurred during pull from remote location'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def repo_as_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

        try:

            fork_id = request.POST.get('id_fork_of')

            repo = ScmModel().mark_as_fork(repo_name, fork_id,

                                    self.rhodecode_user.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

            Session().commit()

            h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork),

                    category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during this operation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def show(self, repo_name, format='html'):

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasRepoPermissionAllDecorator('repository.admin')

    def edit(self, repo_name, format='html'):

        """GET /repos/repo_name/edit: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasPermissionAllDecorator('hg.admin')

    def create_repo_field(self, repo_name):

        try:

            form_result = RepoFieldForm()().to_python(dict(request.POST))

            new_field = RepositoryField()

            new_field.repository = Repository.get_by_repo_name(repo_name)

            new_field.field_key = form_result['new_field_key']

            new_field.field_type = form_result['new_field_type']  # python type

            new_field.field_value = form_result['new_field_value']  # set initial blank value

            new_field.field_desc = form_result['new_field_desc']

            new_field.field_label = form_result['new_field_label']

            Session().add(new_field)

            Session().commit()

        except Exception, e:

            log.error(traceback.format_exc())

            msg = _('An error occurred during creation of field')

            if isinstance(e, formencode.Invalid):

                msg += ". " + e.msg

            h.flash(msg, category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete_repo_field(self, repo_name, field_id):

        field = RepositoryField.get_or_404(field_id)

        try:

            Session().delete(field)

            Session().commit()

        except Exception, e:

            log.error(traceback.format_exc())

            msg = _('An error occurred during removal of field')

            h.flash(msg, category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        except Exception:

            log.error(traceback.format_exc())

            raise

    def toggle_following_user(self, follow_user_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user_id == follow_user_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                return

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def is_following_repo(self, repo_name, user_id, cache=False):

        r = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def is_following_user(self, username, user_id, cache=False):

        u = User.get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repository == repo).count()

    def get_forks(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(Repository)\

                .filter(Repository.fork == repo).count()

    def get_pull_requests(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(PullRequest)\

                .filter(PullRequest.other_repo == repo)\

                .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()

    def mark_as_fork(self, repo, fork, user):

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        if fork and repo.repo_id == fork.repo_id:

            raise Exception("Cannot set repository as fork of itself")

        repo.fork = fork

        self.sa.add(repo)

        return repo

    def _handle_push(self, repo, username, action, repo_name, revisions):

        """

        Triggers push action hooks

        :param repo: SCM repo

        :param username: username who pushes

        :param action: push/push_loca/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        #trigger push hook

        if repo.alias == 'hg':

            log_push_action(_scm_repo.ui, _scm_repo, node=revisions[0])

        elif repo.alias == 'git':

            log_push_action(None, _scm_repo, _git_revs=revisions)

    def _get_IMC_module(self, scm_type):

        """

        Returns InMemoryCommit class based on scm_type

        :param scm_type:

        """

        if scm_type == 'hg':

            from rhodecode.lib.vcs.backends.hg import \

                MercurialInMemoryChangeset as IMC

        elif scm_type == 'git':

            from rhodecode.lib.vcs.backends.git import \

                GitInMemoryChangeset as IMC

        return IMC

    def pull_changes(self, repo, username):

        dbrepo = self.__get_repo(repo)

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        repo_name = dbrepo.repo_name

        try:

            if repo.alias == 'git':

                repo.fetch(clone_uri)

            else:

                repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except Exception:

            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)

        m = IMC(repo)

        m.change(FileNode(path, content))

        tip = m.commit(message=message,

                       author=author,

                       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_node(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        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

        if isinstance(content, (basestring,)):

            content = safe_str(content)

        elif isinstance(content, (file, cStringIO.OutputType,)):

            content = content.read()

        else:

            raise Exception('Content is of unrecognized type %s' % (

                type(content)

            ))

        message = safe_unicode(message)

        author = safe_unicode(author)

        path = safe_str(f_path)

        m = IMC(repo)

        if isinstance(cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [cs]