user = User.get_by_username(username)

        if not user:

            return None

        return dict(id=user.user_id,

    @HasPermissionAllDecorator('hg.admin')

    def get_users(self, apiuser):

        """"

        Get all users

        :param email:

        :param active:

        :param admin:

        :param ldap_dn:

        """

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

        try:

            UserModel().create_or_update(username, password, email, firstname, 

                                         lastname, active, admin, ldap_dn)

            return dict(msg='created new user %s' % username)

        ChangesetCommentsModel().create(text=request.POST.get('text'),

                                        repo_id=c.rhodecode_db_repo.repo_id,

                                        user_id=c.rhodecode_user.user_id,

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

from rhodecode.model.db import Permission, RhodeCodeSetting, User

log = logging.getLogger(__name__)

class PasswordGenerator(object):

        passwd_gen = PasswordGenerator()

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

            of alphabet

        print passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)

    """

    ALPHABETS_NUM = r'''1234567890'''

            log.debug('redirecting to login page with %s', p)

            return redirect(url('login_home', came_from=p))

class NotAnonymous(object):

    redirect to login page"""

    def __call__(self, func):

        return decorator(self.__wrapper, func)

    def __wrapper(self, func, *fargs, **fkwargs):

    def check_permissions(self):

        """Dummy function for overriding"""

        raise Exception('You have to write this function in child class')

class HasPermissionAllDecorator(PermsDecorator):

    have to be meet in order to fulfill the request

    """

    def check_permissions(self):

        if self.required_perms.issubset(self.user_perms.get('global')):

            return True

        return False

class HasPermissionAnyDecorator(PermsDecorator):

    fulfill the request any of predicates must be meet

    """

    def check_permissions(self):

        if self.required_perms.intersection(self.user_perms.get('global')):

            return True

        return False

class HasRepoPermissionAllDecorator(PermsDecorator):

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

    """

    def check_permissions(self):

        repo_name = get_repo_slug(request)

        try:

        if self.required_perms.issubset(user_perms):

            return True

        return False

class HasRepoPermissionAnyDecorator(PermsDecorator):

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

    """

    def check_permissions(self):

        repo_name = get_repo_slug(request)

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        #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 '*'

        """

        paths = self.sa.query(RhodeCodeUi)\

import hashlib

import StringIO

import urllib

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

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

                msg.attach(file_part)

        else:

            raise Exception('Attachment files should be'

                            '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 isinstance(msg_file, str):

            return open(msg_file, "rb").read()

    sa = meta.Session()

    rm = RepoModel()

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

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

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

            added.append(name)

            form_data = {

def create_test_env(repos_test_path, config):

    """Makes a fresh database and

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    import tarfile

    import shutil

    from os.path import abspath

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

            self.sa = meta.Session()

        """

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

        :param cls: class to fetch

        :param instance: int or Instance

        """

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    def __get_changeset_comment(self, changeset_comment):

    def _extract_mentions(self, s):

        user_objects = []

        for username in extract_mentioned_users(s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

        :param revision:

        :param f_path:

        :param line_no:

        """

        if text:

            repo = Repository.get(repo_id)

            comment = ChangesetComment()

            comment.repo = repo

            comment.user_id = user_id

            comment.revision = revision

            comment.text = text

            comment.f_path = f_path

                                   revision=revision,

                                   anchor='comment-%s' % comment.comment_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):

        """

        Deletes given comment

        if cache:

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

                                    "get_api_key_%s" % api_key))

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session().add(self)

        Session().commit()

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

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

            return notification

        elif isinstance(notification, int):

            return Notification.get(notification)

            raise Exception('recipients must be a list of iterable')

        created_by_obj = self.__get_user(created_by)

        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,

                            type_=type_)

    def delete(self, user, notification):

from rhodecode.lib.caching_query import FromCache

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

        """

        perm = self.sa.query(Permission)

        if cache:

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

                                          "get_permission_%s" % permission_id))

        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

        """

        perm = self.sa.query(Permission)\

            .filter(Permission.permission_name == name)

        if len(u2p) != 3:

            raise Exception('Defined: %s should be 3  permissions for default'

                            ' user. This should not happen please verify'

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

                for r2p in self.sa.query(UserRepoToPerm)\

                               .filter(UserRepoToPerm.user == perm_user).all():

                    r2p.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)

            self.sa.commit()

        except (DatabaseError,):

import os

import shutil

import logging

import traceback

from datetime import datetime

from vcs.utils.lazy import LazyProperty

from vcs.backends import get_backend

from rhodecode.lib import safe_str

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import BaseModel

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

    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, RepoGroup

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    @LazyProperty

    def repos_path(self):

        """

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

        return q.ui_value

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

        try:

            cur_repo = self.get_by_repo_name(repo_name, cache=False)

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

                                                perm).scalar()

                    self.sa.add(r2p)

                else:

    def delete_perm_users_group(self, form_data, repo_name):

        try:

            obj = self.sa.query(UsersGroupRepoToPerm)\

                .filter(UsersGroupRepoToPerm.repository \

                        == self.get_by_repo_name(repo_name))\

            self.sa.delete(obj)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

        :param parent_id:

        :param clone_uri:

        """

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

        repo_path = os.path.join(*map(lambda x:safe_str(x),

                                [self.repos_path, new_parent_path, repo_name]))

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

                .filter(UserRepoToPerm.repository == repository) \

                .scalar()

                current.permission = permission

        else:

            p = UserRepoToPerm()

            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:

            self.update_user_permission(repository, user, permission)

        else:

            self.delete_user_permission(repository, user)

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

import os

import time

import traceback

import logging

from vcs import get_backend

from vcs.exceptions import RepositoryError

from vcs.utils.lazy import LazyProperty

from vcs.nodes import FileNode

from rhodecode import BACKENDS

            tmp_d['dbrepo'] = dbr.get_dict()

            tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork \

                                                                    else {}

            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

        """

        log.info('scanning for repositories in %s', repos_path)

            repos_path = self.repos_path

        baseui = make_ui('db')

        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 '

                                          'found in %s' % (name, path))

                else:

        """Puts cache invalidation task into db for

        further global cache invalidation

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

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

                'repository.read': 1,

                'repository.write': 3,

                'repository.admin': 3}

class UserModel(BaseModel):

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

        return user.get(user_id)

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

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

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

        try:

            new_users_group = UsersGroup()

            for k, v in form_data.items():