super(HomeController, self).__before__()

    def index(self):

        c.repos_list = self.scm_model.get_repos()

        c.groups = self.scm_model.get_repos_groups()

        c.group = None

        return render('/index.html')

    def repo_switcher(self):

        if request.is_xhr:

            all_repos = Repository.query().order_by(Repository.repo_name).all()

            c.repos_list = self.scm_model.get_repos(all_repos,

            return render('/repo_switcher_list.html')

        else:

            return HTTPBadRequest()

    def branch_tag_switcher(self, repo_name):

        if request.is_xhr:

            c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            return render('/switch_to_list.html')

        else:

            return HTTPBadRequest()

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

    def __init__(self, db_repo_list, repos_path, order_by=None):

        self.db_repo_list = db_repo_list

        self.repos_path = repos_path

        self.order_by = order_by

        self.reversed = (order_by or '').startswith('-')

    def __len__(self):

        return len(self.db_repo_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

                    '%s this repository is present in database but it '

                    'cannot be created as an scm instance' % dbr.repo_name

                )

                continue

            last_change = scmr.last_change

            tip = h.get_changeset_safe(scmr, 'tip')

            tmp_d = {}

            tmp_d['name'] = dbr.repo_name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['description'] = dbr.description

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

            tmp_d['tip'] = tip.raw_id

            tmp_d['tip_sort'] = tip.revision

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = dbr.user.full_contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['owner_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(scmr._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['author'] = tip.author

            tmp_d['dbrepo'] = dbr.get_dict()

            tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork else {}

            yield tmp_d

class GroupList(object):

    def __init__(self, db_repo_group_list):

        self.db_repo_group_list = db_repo_group_list

    def __len__(self):

        return len(self.db_repo_group_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

    def __iter__(self):

                    klass = get_backend(path[0])

                    if path[0] == 'hg' and path[0] in BACKENDS.keys():

                        repos[name] = klass(safe_str(path[1]), baseui=baseui)

                    if path[0] == 'git' and path[0] in BACKENDS.keys():

                        repos[name] = klass(path[1])

            except OSError:

                continue

        return repos

        """

        Get all repos from db and for each repo create it's

        backend instance and fill that backed with information from database

        :param all_repos: list of repository names as strings

            give specific repositories list, good for filtering

        """

        if all_repos is None:

            all_repos = self.sa.query(Repository)\

                        .filter(Repository.group_id == None)\

                        .order_by(func.lower(Repository.repo_name)).all()

        return repo_iter

    def get_repos_groups(self, all_groups=None):

        if all_groups is None:

            all_groups = RepoGroup.query()\

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

        group_iter = GroupList(all_groups)

        return group_iter

    def mark_for_invalidation(self, repo_name):