return None

        return dict(id=user.user_id,

    @HasPermissionAllDecorator('hg.admin')

    def get_users(self, apiuser):

        :param ldap_dn:

        """

            raise JSONRPCError("user %s already exist" % username)

        try:

                                        revision=revision,

                                        f_path=request.POST.get('f_path'),

                                        line_no=request.POST.get('line'))

        return redirect(h.url('changeset_home', repo_name=repo_name,

                              revision=revision))

    @jsonify

        co = ChangesetComment.get(comment_id)

        owner = lambda : co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            return True

        else:

            raise HTTPForbidden()

class PasswordGenerator(object):

        passwd_gen = PasswordGenerator()

        #print 8-letter password containing only big and small letters

            of alphabet

class NotAnonymous(object):

    redirect to login page"""

    def __call__(self, func):

class HasPermissionAllDecorator(PermsDecorator):

    have to be meet in order to fulfill the request

    """

class HasPermissionAnyDecorator(PermsDecorator):

    fulfill the request any of predicates must be meet

    """

class HasRepoPermissionAllDecorator(PermsDecorator):

    repository. All of them have to be meet in order to fulfill the request

    """

class HasRepoPermissionAnyDecorator(PermsDecorator):

    repository. In order to fulfill the request any of predicates must be meet

    """

        #CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        for step in upgrade_steps:

            print ('performing upgrade step %s' % step)

    def fix_repo_paths(self):

        """Fixes a old rhodecode version path into new one without a '*'

import math

from datetime import datetime

from pygments import highlight as code_highlight

from pylons import url, request, config

from pylons.i18n.translation import _, ungettext

                            'a dict in format {"filename":"filepath"}')

    def get_content(self, msg_file):

        else just read because it's a probably open file object

        :param msg_file:

    if user is None:

        raise Exception('Missing administrative account !')    

    added = []

    for name, repo in initial_repo_list.items():

        group = map_groups(name.split(Repository.url_sep()))

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

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    import tarfile

    import shutil

    from os.path import abspath

        else:

            self.sa = meta.Session()

        """

        Get's instance of given cls using some simple lookup mechanism

class ChangesetCommentsModel(BaseModel):

    def __get_changeset_comment(self, changeset_comment):

    def _extract_mentions(self, s):

        user_objects = []

        """

        if text:

            repo = Repository.get(repo_id)

            comment = ChangesetComment()

            comment.repo = repo

            comment.user_id = user_id

                             )

            body = text

            recipients = ChangesetComment.get_users(revision=revision)

            NotificationModel().create(created_by=user_id, subject=subj,

                                   body=body, recipients=recipients,

                                   type_=Notification.TYPE_CHANGESET_COMMENT)

            return comment

    def delete(self, comment):

                                    "get_api_key_%s" % api_key))

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def __get_user(self, user):

            return User.get_by_username(username=user)

        else:

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

        recipients_objs = []

        for u in recipients:

        recipients_objs = set(recipients_objs)

        return Notification.create(created_by=created_by_obj, subject=subject,

                            body=body, recipients=recipients_objs,

from rhodecode.model import BaseModel

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

log = logging.getLogger(__name__)

class PermissionModel(BaseModel):

    """

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

        :param permission_id: id of permission to get from database

        :param cache: use Cache for this query

        return perm.get(permission_id)

    def get_permission_by_name(self, name, cache=False):

        :param name: name to fetch

        :param cache: Use cache for this query

                            ' your database' % len(u2p))

        try:

            for p in u2p:

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

                    p.permission = self.get_permission_by_name(

                                         form_result['default_perm'])

                    self.sa.add(r2p)

            if perm_user.username == 'default':

                perm_user.active = bool(form_result['anonymous'])

                self.sa.add(perm_user)

import traceback

from datetime import datetime

from vcs.utils.lazy import LazyProperty

from vcs.backends import get_backend

from rhodecode.model import BaseModel

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

    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, RepoGroup

log = logging.getLogger(__name__)

    @LazyProperty

    def repos_path(self):

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

            # update permissions

            for member, perm, member_type in form_data['perms_updates']:

                if member_type == 'user':

                    r2p = self.sa.query(UserRepoToPerm)\

                    r2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.permission_name ==

            obj = self.sa.query(UsersGroupRepoToPerm)\

                .filter(UsersGroupRepoToPerm.repository \

                        == self.get_by_repo_name(repo_name))\

            self.sa.delete(obj)

            self.sa.commit()

        except:

        from rhodecode.lib.utils import is_valid_repo, is_valid_repos_group

        if new_parent_id:

            new_parent_path = os.sep.join(paths)

        else:

            new_parent_path = ''

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        return UserRepoToPerm.query() \

                .filter(UserRepoToPerm.user == user) \

            p.user = user

            p.repository = repository

            p.permission = permission

    def delete_user_permission(self, repository, user):

        current = self.get_user_permission(repository, user)

        if current:

    def update_or_delete_user_permission(self, repository, user, permission):

        if permission:

import traceback

import logging

from vcs import get_backend

from vcs.exceptions import RepositoryError

from vcs.utils.lazy import LazyProperty

            yield tmp_d

class ScmModel(BaseModel):

    """

    @LazyProperty

    def repos_path(self):

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path=None):

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        repos_list = {}

        for name, path in get_filesystem_repos(repos_path, recursive=True):

            # name need to be decomposed and put back together using the /

            # since this is internal storage separator for rhodecode

            name = Repository.url_sep().join(name.split(os.sep))

            try:

                if name in repos_list:

                    raise RepositoryError('Duplicate repository name %s '

        :param repo_name: this repo that should invalidation take place

        """

        CacheInvalidation.set_invalidate(repo_name)

    def toggle_following_repo(self, follow_repo_id, user_id):

class UserModel(BaseModel):

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

        user = self.sa.query(User)

        if cache:

import logging

import traceback

from rhodecode.model import BaseModel

from rhodecode.model.db import UsersGroupMember, UsersGroup

log = logging.getLogger(__name__)

class UsersGroupModel(BaseModel):

    def __get_users_group(self, users_group):

        return UsersGroup.get(users_group_id)

        return UsersGroup.get_by_group_name(name, cache, case_insensitive)

    def create(self, form_data):