from rhodecode.lib.auth import set_available_permissions, set_base_path

from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config

from rhodecode.model import init_model

from sqlalchemy import engine_from_config

import logging

import os

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import UserForm, DefaultPermissionsForm

from rhodecode.model.permission_model import PermissionModel

import formencode

import logging

import traceback

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.db import User

from rhodecode.model.forms import RepoForm

import formencode

import logging

import traceback

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm

from rhodecode.lib.celerylib import tasks, run_task

import formencode

import logging

        GET /_admin/my_account Displays info about my account 

        """

        # url('admin_settings_my_account')

        c.user_repos = []

        for repo in c.cached_repo_list.values():

            if repo.dbrepo.user.username == c.user.username:

                    category='success')

        except formencode.Invalid, errors:

            c.user_repos = []

            for repo in c.cached_repo_list.values():

                if repo.dbrepo.user.username == c.user.username:

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import User, UserLog

from rhodecode.model.forms import UserForm

import formencode

import logging

import traceback

        #           method='put')

        # url('user', id=ID)

        user_model = UserModel()

        _form = UserForm(edit=True, old_data={'user_id':id,

                                              'email':c.user.email})()

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict

import logging

log = logging.getLogger(__name__)

from pylons import request, session, tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from webhelpers.paginate import Page

import logging

log = logging.getLogger(__name__)

from pylons.controllers.util import redirect

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

"""

from pylons import tmpl_context as c, url, response

from rhodecode.lib.base import BaseController, render

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

import logging

log = logging.getLogger(__name__)

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import EmptyChangeset

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

import logging

log = logging.getLogger(__name__)

import rhodecode.lib.helpers as h 

from pylons.i18n.translation import _

from rhodecode.model.forms import LoginForm, RegisterForm, PasswordResetForm

import formencode

import logging

            try:

                c.form_result = login_form.to_python(dict(request.POST))

                username = c.form_result['username']

                auth_user = AuthUser()

                auth_user.username = user.username

                auth_user.is_authenticated = True

    def register(self):

        user_model = UserModel()

        c.auto_active = False

            if perm.permission.permission_name == 'hg.register.auto_activate':

                c.auto_active = True

                break

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

import formencode

import logging

import rhodecode.lib.helpers as h

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from webhelpers.paginate import Page

import logging

log = logging.getLogger(__name__)

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict

from rhodecode.model.db import Statistics

from webhelpers.paginate import Page

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict

import logging

log = logging.getLogger(__name__)

@author: marcink

"""

from pylons import config, session, url, request

from pylons.controllers.util import abort, redirect

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model.caching_query import FromCache

from rhodecode.model.db import User, RepoToPerm, Repository, Permission, \

    UserToPerm

import bcrypt

from decorator import decorator

import logging

def check_password(password, hashed):

    return bcrypt.hashpw(password, hashed) == hashed

def authfunc(environ, username, password):

    if user:

        if user.active:

    """

    log.info('getting information about all available permissions')

    try:

        all_perms = sa.query(Permission).all()

    finally:

        meta.Session.remove()

    in database

    :param user:

    """

        .get(user.user_id)

    if dbuser:

        user.username = dbuser.username

        user.is_admin = dbuser.admin

        user.email = dbuser.email

    else:

        user.is_authenticated = False

    return user

def fill_perms(user):

    :param user:

    """

    user.permissions['repositories'] = {}

    user.permissions['global'] = set()

from rhodecode.lib import auth

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

    _get_repos_switcher_cached

class BaseController(WSGIController):

                c.repository_tags = {}

                c.repository_branches = {}

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

    else:

        #If we don't use celery reuse our current application Session

        from rhodecode.model.meta import Session

    return sa

@task

def create_repo_fork(form_data, cur_user):

    import os

    sa = get_session()

    rm = RepoModel(sa)

        dburi = 'sqlite:////%s' % jn(self.root, self.dbname)

        engine = create_engine(dburi, echo=log_sql) 

        init_model(engine)

        self.db_exists = False

    def check_for_db(self, override):

    """

    try:

        username = kwargs['url'].split(':')[-1]

        user_log = sa.query(UserLog)\

            .filter(UserLog.user == sa.query(User)\

from os.path import dirname as dn, join as jn

from rhodecode.config.environment import load_environment

from shutil import rmtree

from webhelpers.html.builder import escape

from vcs.utils.lazy import LazyProperty

sys.path.append(project_path)

from rhodecode.lib.pidlock import LockHeld, DaemonLock

from rhodecode.lib.helpers import safe_unicode

from whoosh.index import create_in, open_dir

from shutil import rmtree

from mercurial.hgweb.request import wsgiapplication

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from rhodecode.lib.utils import is_mercurial, make_ui, invalidate_cache, \

    check_repo_fast, ui_sections

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError

from rhodecode.lib.utils import action_logger

import logging

        return environ.get('REMOTE_USER')

    def __get_user(self, username):

    def __get_action(self, environ):

        """

Utilities for RhodeCode

@author: marcink

"""

from mercurial import ui, config, hg

from mercurial.error import RepoError

from rhodecode.model import meta

from rhodecode.model.db import Repository, User, RhodeCodeUi, RhodeCodeSettings, UserLog

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

    """

    if not sa:

    try:

        if hasattr(user, 'user_id'):

            user_id = user.user_id

        elif isinstance(user, basestring):

        else:

            raise Exception('You have to provide user object or username')

        user_log.user_id = user_id

        user_log.action = action

        user_log.repository_name = repo_name

        user_log.action_date = datetime.datetime.now()

        user_log.user_ip = ipaddr

        sa.add(user_log)

        if retries < 0: raise IOError

        print complaint

def get_hg_ui_cached():

    try:

        sa = meta.Session

    finally:

        meta.Session.remove()

    return ret

def get_hg_settings():

    try:

    finally:

        meta.Session.remove()

def get_hg_ui_settings():

    try:

        ret = sa.query(RhodeCodeUi).all()

    finally:

        meta.Session.remove()

    args = tuple(tmp)

    if name == 'cached_repo_list':

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        region_invalidate(_full_changelog_cached, None, *args)

class EmptyChangeset(BaseChangeset):

    """

    maps all found repositories into db

    """

    user = sa.query(User).filter(User.admin == True).first()

    rm = RepoModel()

    for name, repo in initial_repo_list.items():

            log.info('repository %s not found creating default', name)

            form_data = {

#===============================================================================

#===============================================================================

def create_test_index(repo_location, full_index):

    """Makes default test index

from pylons.i18n.translation import _

from rhodecode.lib.auth import check_password, get_crypt_password

from rhodecode.model import meta

from webhelpers.pylonslib.secure_form import authentication_token

import formencode

import logging

import os

import rhodecode.lib.helpers as h

log = logging.getLogger(__name__)

#this is needed to translate the messages using _() in validators

class State_obj(object):

    _ = staticmethod(_)

        def validate_python(self, value, state):

            if value in ['default', 'new_user']:

                raise formencode.Invalid(_('Invalid username'), value, state)

            old_un = None

            if edit:

            if old_un != value or not edit:    

                    raise formencode.Invalid(_('This username already exists') ,

                                             value, state)

    return _ValidUsername   

    def validate_python(self, value, state):

        password = value['password']

        username = value['username']

        if user is None:

            raise formencode.Invalid(self.message('invalid_password',

                                     state=State_obj), value, state,

class ValidRepoUser(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        try:

                .filter(User.active == True)\

                .filter(User.username == value).one()

        except Exception:

                raise formencode.Invalid(_('This repository name is disallowed'),

                                         value, state)

            if old_data.get('repo_name') != value or not edit:    

                    raise formencode.Invalid(_('This repository already exists') ,

                                             value, state)

            return slug 

    class _UniqSystemEmail(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            if old_data.get('email') != value:

                try:

                    user = sa.query(User).filter(User.email == value).scalar()

                    if user:

from beaker.cache import cache_region

from mercurial import ui

from mercurial.hgweb.hgwebdir_mod import findrepos

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import invalidate_cache

from rhodecode.lib.auth import HasRepoPermissionAny

@author: marcink

"""

from rhodecode.model.db import User, Permission, UserToPerm, RepoToPerm

from rhodecode.model.meta import Session

import logging

import traceback

class PermissionModel(object):

        self.sa = Session() 

    def update(self, form_result):

        perm_user = self.sa.query(User)\

                .filter(User.username == form_result['perm_user_name']).scalar()

        u2p = self.sa.query(UserToPerm).filter(UserToPerm.user == perm_user).all()

        if len(u2p) != 3:

        try:

            #stage 1 change defaults    

"""

Created on Jun 5, 2010

model for handling repositories actions

"""

from datetime import datetime

from pylons import app_globals as g

from rhodecode.model.db import Repository, RepoToPerm, User, Permission

from rhodecode.model.meta import Session

import logging

import os

import shutil

        else:

            self.sa = sa

    def get_users_js(self):

            #update permissions

            for username, perm in form_data['perms_updates']:

                r2p = self.sa.query(RepoToPerm)\

                        .filter(RepoToPerm.repository == self.get(repo_name))\

                        .one()

            for username, perm in form_data['perms_new']:

                r2p = RepoToPerm()

                r2p.repository = self.get(repo_name)

                r2p.permission_id = self.sa.query(Permission).filter(

                                        Permission.permission_name == perm)\

                self.sa.add(r2p)

            #update current repo

            for k, v in form_data.items():

                if k == 'user':

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

                if p.permission.permission_name.startswith('repository.'):

                    default = p.permission.permission_name

                    break

                    .one().permission_id

            repo_to_perm.repository_id = new_repo.repo_id

            self.sa.add(repo_to_perm)

            self.sa.commit()

            raise    

    def create_fork(self, form_data, cur_user):

    def delete(self, repo):

        try:

            raise

    def __create_repo(self, repo_name):