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.user import UserModel

import formencode

import logging

import traceback

log = logging.getLogger(__name__)

        _form = RepoForm(edit=True, old_data={'repo_name':repo_name})()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

                    category='success')

            changed_name = form_result['repo_name']

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

    def my_account(self):

        """

        GET /_admin/my_account Displays info about my account 

        """

        # url('admin_settings_my_account')

        all_repos = self.sa.query(Repository)\

            .filter(Repository.user_id == c.user.user_id)\

            .order_by(func.lower(Repository.repo_name))\

            .all()

        c.user_repos = ScmModel().get_repos(all_repos)

            user_model.update_my_account(uid, form_result)

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

                    category='success')

        except formencode.Invalid, errors:

            c.user = user_model.get(c.rhodecode_user.user_id, cache=False)

            all_repos = self.sa.query(Repository)\

                .filter(Repository.user_id == c.user.user_id)\

                .order_by(func.lower(Repository.repo_name))\

                .all()

            c.user_repos = ScmModel().get_repos(all_repos)

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

"""

Created on April 4, 2010

users controller for pylons

@author: marcink

"""

    user.permissions['repositories'] = {}

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

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

    # fetch default permissions

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

    default_perms = sa.query(RepoToPerm, Repository, Permission)\

        .join((Repository, RepoToPerm.repository_id == Repository.repo_id))\

        .join((Permission, RepoToPerm.permission_id == Permission.permission_id))\

        .filter(RepoToPerm.user == default_user).all()

from celery.decorators import task

from operator import itemgetter

from pylons.i18n.translation import _

from rhodecode.lib.celerylib import run_task, locked_task

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict

from vcs.backends import get_repo

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

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

        from rhodecode.model.meta import Session

        sa = Session()

    return sa

@task

@locked_task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    index_location = dict(config.items('app:main'))['index_dir']

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    last_rev = 0

@task

def create_repo_fork(form_data, cur_user):

    from rhodecode.model.repo import RepoModel

    from vcs import get_backend

    log = create_repo_fork.get_logger()

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

    repo_name = form_data['repo_name']

    repo_path = os.path.join(repos_path, repo_name)

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

    alias = form_data['repo_type']

    log.info('creating repo fork %s as %s', repo_name, repo_path)

    backend = get_backend(alias)

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        sa = meta.Session()

    try:

        if hasattr(user, 'user_id'):

            user_obj = user

        elif isinstance(user, basestring):

        else:

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

        if repo:

            repo_name = repo.lstrip('/')

            if not repository:

                raise Exception('You have to provide valid repository')

        else:

            raise Exception('You have to provide repository to action logger')

def set_rhodecode_config(config):

    hgsettings = get_hg_settings()

    for k, v in hgsettings.items():

        config[k] = v

    """

    Puts cache invalidation task into db for 

    further global cache invalidation

    """

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset. It's possible to pass hash when creating

    an EmptyChangeset

    """

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    sa = meta.Session()

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

    for name, repo in initial_repo_list.items():

        if not rm.get(name, cache=False):

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

    user = relation('User')

    fork = relation('Repository', remote_side=repo_id)

    repo_to_perm = relation('RepoToPerm', cascade='all')

    stats = relation('Statistics', cascade='all')

    def __repr__(self):

class Permission(Base):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

    permission_id = Column("permission_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    permission_name = Column("permission_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    languages = Column("languages", BLOB(), nullable=False)#JSON data

    repository = relation('Repository', single_parent=True)

class CacheInvalidation(Base):

    __tablename__ = 'cache_invalidation'

    cache_id = Column("cache_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    cache_key = Column("cache_key", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_args = Column("cache_args", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

import traceback

log = logging.getLogger(__name__)

class PermissionModel(object):

    def get_permission(self, permission_id, cache=False):

        perm = self.sa.query(Permission)

        if cache:

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

                                          "get_permission_%s" % permission_id))

import shutil

import traceback

log = logging.getLogger(__name__)

class RepoModel(object):

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

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_id)

        if cache:

    def update(self, repo_name, form_data):

        try:

            #update permissions

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

                r2p = self.sa.query(RepoToPerm)\

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

                        .one()

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

                                                Permission.permission_name ==

                                                perm).one().permission_id

                self.sa.add(r2p)

            #set new permissions

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

                                        .one().permission_id

                self.sa.add(r2p)

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

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

                    default = p.permission.permission_name

                    break

            default_perm = 'repository.none' if form_data['private'] else default

            repo_to_perm.permission_id = self.sa.query(Permission)\

                    .filter(Permission.permission_name == default_perm)\

                    .one().permission_id

            repo_to_perm.repository_id = new_repo.repo_id

            self.sa.add(repo_to_perm)

            self.sa.commit()

            if not just_db:

                self.__create_repo(repo_name, form_data['repo_type'])

        except:

from beaker.cache import cache_region, region_invalidate

from mercurial import ui

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny

from rhodecode.lib.utils import get_repos

from rhodecode.model import meta

from sqlalchemy.orm import joinedload

from vcs import get_backend

from vcs.utils.helpers import get_scm

from vcs.exceptions import RepositoryError, VCSError

from vcs.utils.lazy import LazyProperty

import logging

import os

import time

log = logging.getLogger(__name__)

class ScmModel(object):

    """

    Mercurial Model

    """

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        :param repo_name:

        """

        if not HasRepoPermissionAny('repository.read', 'repository.write',

                            'repository.admin')(repo_name, 'get repo check'):

            return

        def _get_repo(repo_name):

            repo_path = os.path.join(self.repos_path, repo_name)

            alias = get_scm(repo_path)[0]

            log.debug('Creating instance of %s repository', alias)

            dbrepo = self.sa.query(Repository)\

                .options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .filter(Repository.repo_name == repo_name)\

                .scalar()

            repo.dbrepo = dbrepo

            return repo

        if invalidate:

            region_invalidate(_get_repo, None, repo_name)

        return _get_repo(repo_name)

log = logging.getLogger(__name__)

class DefaultUserException(Exception):pass

class UserModel(object):

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

        user = self.sa.query(User)

        if cache:

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

                                          "get_user_%s" % user_id))