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_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

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

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        repo.fork = fork

        self.sa.add(repo)

        return repo

    def pull_changes(self, repo_name, username):

        dbrepo = Repository.get_by_repo_name(repo_name)

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

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

        repo = dbrepo.scm_instance

        try:

            #inject ui extra param to log this action via push logger

            for k, v in extras.items():

                repo._repo.ui.setconfig('rhodecode_extras', k, v)

            repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except:

            log.error(traceback.format_exc())

            raise

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

                      content, f_path):

        if repo.alias == 'hg':

        elif repo.alias == 'git':

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

        new_cs = tip.short_id

        action = 'push_local:%s' % new_cs

        action_logger(user, action, repo_name)

        self.mark_for_invalidation(repo_name)

    def create_node(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        if repo.alias == 'hg':

            from rhodecode.lib.vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import GitInMemoryChangeset as IMC

        # 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