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, invalidation_list, repos_path,

                 order_by=None):

        self.db_repo_list = db_repo_list

        self.invalidation_list = invalidation_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__())

    def __iter__(self):

        for db_repo in self.db_repo_list:

            dbr = db_repo

            # invalidate the repo cache if needed before getting the 

            # scm instance

            scm_invalidate = False

            if self.invalidation_list is not None:

                scm_invalidate = dbr.repo_name in self.invalidation_list

            if scm_invalidate:

                log.info('invalidating cache for repository %s',

                         dbr.repo_name)

                db_repo.set_invalidate

            scmr = db_repo.scm_instance_cached

            #check permission at this level

            if not HasRepoPermissionAny('repository.read',

                                        'repository.write',

                                        'repository.admin')(dbr.repo_name,

                                                            'get repo check'):

                continue

                log.error('%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['description_sort'] = tmp_d['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['repo'] = scmr

            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

    """

    @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