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

        from rhodecode import CONFIG

        from rhodecode.lib.base import _get_ip_addr

        try:

            from pylons import request

            environ = request.environ

        except TypeError:

            # we might use this outside of request context, let's fake the

            # environ data

            from webob import Request

            environ = Request.blank('').environ

        extras = {

            'ip': _get_ip_addr(environ),

            'username': username,

            'repository': repo_name,

            'scm': repo_alias,

            'config': CONFIG['__file__'],

            'server_url': get_server_url(environ),

            'make_lock': None,

            'locked_by': [None, None]

        }

        _set_extras(extras)

    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

        """

        self._handle_rc_scm_extras(username, repo_name, repo_alias=repo.alias)

        _scm_repo = repo._repo

        # 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)

        imc = IMC(repo)

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

        tip = imc.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_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

        """

        user = self._get_user(user)

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        for f_path in nodes:

            if f_path.startswith('/') or f_path.startswith('.') or '../' in f_path:

                raise NonRelativePathError('%s is not an relative path' % f_path)

            if f_path:

                f_path = os.path.normpath(f_path)

            f_path = safe_str(f_path)

            content = nodes[f_path]['content']

            # 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)

                ))

            processed_nodes.append((f_path, content))

        message = safe_unicode(message)

        commiter = user.full_contact

        author = safe_unicode(author) if author else commiter

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.add(FileNode(path, content=content))