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 ScmModel(BaseModel):

    """

    Generic Scm Model

    """

    def __get_repo(self, instance):

        cls = Repository

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, int) or str(instance).isdigit():

            return cls.get(instance)

        elif isinstance(instance, basestring):

            return cls.get_by_repo_name(instance)

        elif instance:

            raise Exception('given object must be int, basestr or Instance'

                            ' of %s got %s' % (type(cls), type(instance)))

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path=None):

        """

        Listing of repositories in given path. This path should not be a

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        """

        if repos_path is None:

            repos_path = self.repos_path

        baseui = make_ui('db')

        repos = {}

        for name, path in get_filesystem_repos(repos_path, recursive=True):

            # name need to be decomposed and put back together using the /

            # since this is internal storage separator for rhodecode

            name = Repository.url_sep().join(name.split(os.sep))

            try:

                if name in repos:

                    raise RepositoryError('Duplicate repository name %s '

                                          'found in %s' % (name, path))

                else:

                    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

    def get_repos(self, all_repos=None, sort_key=None):

        """

        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(Repository.repo_name).all()

        repo_iter = CachedRepoList(all_repos, repos_path=self.repos_path,

                                   order_by=sort_key)

        return repo_iter

    def mark_for_invalidation(self, repo_name):

        """Puts cache invalidation task into db for

        further global cache invalidation