from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

from rhodecode.config.routing import make_map

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

import rhodecode.lib.app_globals as app_globals

import rhodecode.lib.helpers

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

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

log = logging.getLogger(__name__)

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

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

log = logging.getLogger(__name__)

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    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

import traceback

log = logging.getLogger(__name__)

    def my_account(self):

        """

        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:

                c.user_repos.append(repo)

        if c.user.username == 'default':

            form_result = _form.to_python(dict(request.POST))

            user_model.update_my_account(uid, form_result)

            h.flash(_('Your account was updated succesfully'),

                    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:

                    c.user_repos.append(repo)            

            return htmlfill.render(

                render('admin/users/user_edit_my_account.html'),

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

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

log = logging.getLogger(__name__)

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('user', id=ID),

        #           method='put')

        # url('user', id=ID)

        user_model = UserModel()

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

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

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

@author: marcink

"""

from pylons import tmpl_context as c

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

class BranchesController(BaseController):

    @LoginRequired()

    #python 2.5 compatibility

    import simplejson as json

from mercurial.graphmod import colored, CHANGESET, revisions as graph_rev

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

class ChangelogController(BaseController):

"""

from pylons import tmpl_context as c, url, request, response

from pylons.i18n.translation import _

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

import logging

import traceback

Created on April 23, 2010

feed controller for pylons

@author: marcink

"""

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

class FeedController(BaseController):

from pylons import request, response, session, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

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

import logging

import rhodecode.lib.helpers as h

import tempfile

@author: marcink

"""

from operator import itemgetter

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

class HgController(BaseController):

    @LoginRequired()

from pylons.controllers.util import abort, redirect

from rhodecode.lib.auth import AuthUser, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

import rhodecode.lib.helpers as h 

from pylons.i18n.translation import _

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

import formencode

import logging

log = logging.getLogger(__name__)

class LoginController(BaseController):

        if request.POST:

            #import Login Form validator class

            login_form = LoginForm()

            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

                auth_user.is_admin = user.admin

                auth_user.user_id = user.user_id

                auth_user.name = user.name

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        user_model = UserModel()

        c.auto_active = False

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

                c.auto_active = True

                break

        if request.POST:

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator

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

import traceback

log = logging.getLogger(__name__)

shortlog controller for pylons

@author: marcink

"""

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

class ShortlogController(BaseController):

@author: marcink

"""

from pylons import tmpl_context as c, request, url

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.celerylib.tasks import get_commits_stats

from datetime import datetime, timedelta

from time import mktime

@author: marcink

"""

from pylons import tmpl_context as c

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

class TagsController(BaseController):

    @LoginRequired()

# MA  02110-1301, USA.

"""

Created on April 4, 2010

@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 import meta

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

import random

log = logging.getLogger(__name__) 

    """    

    return bcrypt.hashpw(password, bcrypt.gensalt(10))

def check_password(password, hashed):

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

def authfunc(environ, username, password):

    if user:

        if user.active:

            if user.username == username and check_password(password, user.password):

                log.info('user %s authenticated correctly', username)

                return True

    permissions since adding a new permission also requires application restart

    ie. to decorate new views with the newly created permission

    :param config:

    """

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

    try:

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

    finally:

        meta.Session.remove()

    config['available_permissions'] = [x.permission_name for x in all_perms]

def set_base_path(config):

def fill_data(user):

    """

    Fills user data with those from database and log out user if not present

    in database

    :param user:

    """

        .get(user.user_id)

    if dbuser:

        user.username = dbuser.username

        user.is_admin = dbuser.admin

        user.name = dbuser.name

        user.lastname = dbuser.lastname

        user.email = dbuser.email

    else:

        user.is_authenticated = False

    return user

def fill_perms(user):

    """

    Fills user permission attribute with permissions taken from database

    :param user:

    """

    user.permissions['repositories'] = {}

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

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

    # fetch default permissions

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

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

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

    def __before__(self):

        c.rhodecode_version = __version__

                c.repository_tags = cached_repo.tags

                c.repository_branches = cached_repo.branches

            else:

                c.repository_tags = {}

                c.repository_branches = {}

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        from sqlalchemy.orm import sessionmaker, scoped_session

        engine = engine_from_config(dict(config.items('app:main')), 'sqlalchemy.db1.')

        sa = scoped_session(sessionmaker(bind=engine))

    else:

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

        from rhodecode.model.meta import Session

    return sa

def get_hg_settings():

    from rhodecode.model.db import RhodeCodeSettings

    sa = get_session()

        return False

    return True

@task

def create_repo_fork(form_data, cur_user):

    import os

    sa = get_session()

    rm = RepoModel(sa)

    rm.create(form_data, cur_user, just_db=True, fork=True)

    repos_path = get_hg_ui_settings()['paths_root_path'].replace('*', '')

        self.dbname = dbname

        self.tests = tests

        self.root = root

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

        db_path = jn(self.root, self.dbname)

        log.info('checking for existing db in %s', db_path)

        if os.path.isfile(db_path):

    :param ui:

    :param repo:

    :param hooktype:

    """

    try:

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

        user_log = sa.query(UserLog)\

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

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

            .order_by(UserLog.user_log_id.desc()).first()

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

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, Schema, FieldType

#to get the rhodecode import

project_path = dn(dn(dn(dn(os.path.realpath(__file__)))))

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 rhodecode.lib.indexers import INDEX_EXTENSIONS, IDX_LOCATION, SCHEMA, IDX_NAME

from time import mktime

from itertools import chain

from mercurial.error import RepoError

from mercurial.hgweb import hgweb

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

import os

import traceback

        return  self.__load_web_settings(hgserve)

    def __get_environ_user(self, environ):

        return environ.get('REMOTE_USER')

    def __get_user(self, username):

    def __get_action(self, environ):

        """

        Maps mercurial request commands into a clone,pull or push command.

        This should always return a valid command string

        :param environ:

"""

Created on April 18, 2010

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

import logging

import datetime

import os

def action_logger(user, action, repo, ipaddr, sa=None):

    """

    Action logger for various action made by users

    """

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

        repo_name = repo.lstrip('/')

        user_log = UserLog()

        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)

        sa.commit()

        log.info('Adding user %s, action %s on %s',

        if ok in ('y', 'ye', 'yes'): return True

        if ok in ('n', 'no', 'nop', 'nope'): return False

        retries = retries - 1

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

    if not ret:

        raise Exception('Could not get application settings !')

    settings = {}

        settings['rhodecode_' + each.app_settings_name] = each.app_settings_value

    return settings

def get_hg_ui_settings():

    try:

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

    finally:

        meta.Session.remove()

    if not ret:

        raise Exception('Could not get application ui settings !')

    settings = {}

    without that the invalidation would not work"""

    tmp = [name]

    tmp.extend(args)

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

    """

    An dummy empty changeset.

    """

        return 0

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    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 = {

                         'repo_name':name,

                         'description':repo.description if repo.description != 'unknown' else \

                                        'auto description for %s' % name,

    def __ne__(self, other):

        return not self == other

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

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

def create_test_index(repo_location, full_index):

    """Makes default test index

    :param repo_location:

    :param full_index:

    """

from formencode.validators import UnicodeString, OneOf, Int, Number, Regex, \

    Email, Bool, StringBoolean

from pylons import session

from pylons.i18n.translation import _

from rhodecode.lib.auth import check_password, get_crypt_password

from rhodecode.model import meta