self.rhodecode_user = c.rhodecode_user = AuthUser(user_id, api_key)

            self.rhodecode_user.set_authenticated(

                                        getattr(session.get('rhodecode_user'),

                                       'is_authenticated', False))

            session['rhodecode_user'] = self.rhodecode_user

            session.save()

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

class BaseRepoController(BaseController):

    """

    Base class for controllers responsible for loading all needed data

    for those controllers, loaded items are

    c.rhodecode_repo: instance of scm repository (taken from cache)

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            if c.rhodecode_repo is not None:

                c.repository_followers = \

                    self.scm_model.get_followers(c.repo_name)

                c.repository_forks = self.scm_model.get_forks(c.repo_name)

            else:

                c.repository_followers = 0

                c.repository_forks = 0

        return q.ui_value

    def get(self, repo_id, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_id == repo_id)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_id))

        return repo.scalar()

    def get_by_repo_name(self, repo_name, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_full(self, repo_name, cache=False, invalidate=False):

        repo = self.sa.query(Repository)\

            .options(joinedload(Repository.fork))\

            .options(joinedload(Repository.user))\

            .filter(Repository.repo_name == repo_name)\

        if cache:

            repo = repo.options(FromCache("sql_cache_long",

                                          "get_repo_full_%s" % repo_name))

        if invalidate and cache:

            repo.invalidate()

        ret = repo.scalar()

        #make transient for sake of errors

        make_transient(ret)

            attr = getattr(ret, k, False)

            if attr:

                make_transient(attr)

        return ret

    def get_users_js(self):

        users = self.sa.query(User).filter(User.active == True).all()

        u_tmpl = '''{id:%s, fname:"%s", lname:"%s", nname:"%s"},'''

        users_array = '[%s]' % '\n'.join([u_tmpl % (u.user_id, u.name,

                                                    u.lastname, u.username)

                                        for u in users])

        return users_array

    def get_users_groups_js(self):

        users_groups = self.sa.query(UsersGroup)\

            .filter(UsersGroup.users_group_active == True).all()

        g_tmpl = '''{id:%s, grname:"%s",grmembers:"%s"},'''

        users_groups_array = '[%s]' % '\n'.join([g_tmpl % \

                                    (gr.users_group_id, gr.users_group_name,

                                     len(gr.members))

                                        for gr in users_groups])