"""

        if groups is None:

            groups = RepoGroup.query() \

                .filter(RepoGroup.parent_group_id == None).all()

        return RepoGroupList(groups, perm_level='read')

    def mark_for_invalidation(self, repo_name):

        """

        Mark caches of this repo invalid in the database.

        :param repo_name: the repo for which caches should be marked invalid

        """

        CacheInvalidation.set_invalidate(repo_name)

        repo = Repository.get_by_repo_name(repo_name)

        if repo is not None:

            repo.update_changeset_cache()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = UserFollowing.query() \

            .filter(UserFollowing.follows_repository_id == follow_repo_id) \

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

        if f is not None:

                # we fake that now.

                # TODO: extract fetched revisions ... somehow ...

                self._handle_push(repo,

                                  username=username,

                                  ip_addr=ip_addr,

                                  action='push_remote',

                                  repo_name=repo_name,

                                  revisions=[])

            else:

                set_hook_environment(username, ip_addr, dbrepo.repo_name,

                                           repo.alias, action='push_remote')

                repo.pull(clone_uri)

        except Exception:

            log.error(traceback.format_exc())

            raise

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

                      content, f_path):

        """

        Commit a change to a single file

        :param repo: a db_repo.scm_instance

        """

        user = User.guess_instance(user)

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

        try:

            tip = imc.commit(message=message, author=author,

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

        except Exception as e:

            log.error(traceback.format_exc())

            raise IMCCommitError(str(e))

        self._handle_push(repo,

                          username=user.username,

                          ip_addr=ip_addr,

                          action='push_local',

                          repo_name=repo_name,

                          revisions=[tip.raw_id])

        return tip

    def _sanitize_path(self, f_path):

        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:

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

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

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        return tip

    def update_nodes(self, user, ip_addr, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Commits specified nodes to repo. Again.

        """

        user = User.guess_instance(user)

        scm_instance = repo.scm_instance_no_cache()

        message = safe_unicode(message)

        committer = user.full_contact

                    # TODO: handle renames, needs vcs lib changes

                    imc.remove(filenode)

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

                else:

                    imc.change(filenode)

        # commit changes

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

    def delete_nodes(self, user, ip_addr, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Deletes specified nodes from repo.

        :param user: Kallithea User object or user_id, the committer

        :param repo: Kallithea 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 committer only for git

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

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

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        return tip

    def get_unread_journal(self):

        return UserLog.query().count()

    def get_repo_landing_revs(self, repo=None):

        """

        Generates select option with tags branches and bookmarks (for hg only)

        grouped by type

        :param repo:

        """