:param apiuser:

        :param username:

        :param password:

        :param name:

        :param lastname:

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

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create user %s' % username)

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, group_name):

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    def comment(self, repo_name, revision):

        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.lib.exceptions import LdapPasswordError, LdapUsernameError

from rhodecode.lib.utils import get_repo_slug

from rhodecode.lib.auth_ldap import AuthLdap

from rhodecode.model import meta

from rhodecode.model.user import UserModel

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

    ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''

    ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''

    ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''

    ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL \

        + ALPHABETS_NUM + ALPHABETS_SPECIAL

    ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM

        if user.is_authenticated or api_access_ok:

            log.debug('user %s is authenticated', user.username)

            return func(*fargs, **fkwargs)

        else:

            log.warn('user %s NOT authenticated', user.username)

            p = url.current()

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

        cls = fargs[0]

        self.user = cls.rhodecode_user

        log.debug('Checking if user is not anonymous @%s', cls)

        anonymous = self.user.username == 'default'

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

            else:

                # redirect with forbidden ret code

                return abort(403)

    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:

            user_perms = set([self.user_perms['repositories'][repo_name]])

        except KeyError:

            return False

        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)

        try:

            user_perms = set([self.user_perms['repositories'][repo_name]])

        except KeyError:

            return False

        if self.required_perms.intersection(user_perms):

            return True

            def step_3(self):

                print ('Adding additional settings into RhodeCode db')

                self.klass.fix_settings()

                print ('Adding ldap defaults')

                self.klass.create_ldap_options(skip_existing=True)

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

                .filter(RhodeCodeUi.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

"""Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import random

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 *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, form, hidden, image, javascript_link, link_to, link_to_if, \

    link_to_unless, ol, required_legend, select, stylesheet_link, submit, text, \

    password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, js_obfuscate, \

                    # Encode the payload using Base64

                    encoders.encode_base64(msg)

                # Set the filename parameter

                file_part.add_header('Content-Disposition', 'attachment',

                                     filename=f_name)

                file_part.add_header('Content-Type', ctype, name=f_name)

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

        else:

            # just for safe seek to 0

            msg_file.seek(0)

            return msg_file.read()

    that are not in initial_repo_list and removes them.

    :param initial_repo_list: list of repositories found by scanning methods

    :param remove_obsolete: check for obsolete entries in database

    """

    from rhodecode.model.repo import RepoModel

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

                         'repo_name': name,

                         'repo_name_full': name,

                         'repo_type': repo.alias,

                         'description': repo.description \

                            if repo.description != 'unknown' else \

                                        '%s repository' % name,

                             repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

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

    log.debug('making test db %s', dbconf)

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

        log.debug('Creating testdir %s' % repos_test_path)

        os.makedirs(repos_test_path)

    """Base Model for all RhodeCode models, it adds sql alchemy session

    into instance of model

    :param sa: If passed it reuses this session instead of creating a new one

    """

    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

        """

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, int) or str(instance).isdigit():

            return cls.get(instance)

        else:

from rhodecode.lib import extract_mentioned_users

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import ChangesetComment, User, Repository, Notification

from rhodecode.model.notification import NotificationModel

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:

                user_objects.append(user_obj)

        return user_objects

    def create(self, text, repo_id, user_id, revision, f_path=None,

               line_no=None):

        """

        Creates new comment for changeset

        :param text:

        :param repo_id:

        :param user_id:

        :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

            comment.line_no = line_no

            self.sa.add(comment)

            self.sa.flush()

            # make notification

            line = ''

            if line_no:

                line = _('on line %s') % line_no

            subj = h.link_to('Re commit: %(commit_desc)s %(line)s' % \

                                    {'commit_desc':desc, 'line':line},

                             h.url('changeset_home', repo_name=repo.repo_name,

                                   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

        :param comment_id:

        """

        comment = self.__get_changeset_comment(comment)

        self.sa.delete(comment)

        return comment

                                    "get_user_%s" % username))

        return q.scalar()

    @classmethod

    def get_by_api_key(cls, api_key, cache=False):

        q = cls.query().filter(cls.api_key == api_key)

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

        log.debug('updated user %s lastlogin', self.username)

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'extend_existing':True}

import logging

import traceback

from pylons.i18n.translation import _

from rhodecode.lib.helpers import age

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)

        else:

            if notification:

                raise Exception('notification must be int or Instance'

                                ' of Notification got %s' % type(notification))

        :param body:

        :param recipients: list of int, str or User objects

        :param type_: type of notification

        """

        if not getattr(recipients, '__iter__', False):

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

        # we don't want to remove actual notification just the assignment

        try:

            notification = self.__get_notification(notification)

            user = self.__get_user(user)

            if notification and user:

                obj = UserNotification.query().filter(UserNotification.user == user)\

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

import logging

import traceback

from sqlalchemy.exc import DatabaseError

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

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

                                          "get_permission_%s" % name))

        return perm.scalar()

    def update(self, form_result):

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_id == repo_id)

        if cache:

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

                                          "get_repo_%s" % repo_id))

                             p.permission.permission_name})

        return defaults

    def update(self, repo_name, form_data):

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

                            .filter(UserRepoToPerm.repository == cur_repo)\

                            .one()

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

                                        .filter(Permission.permission_name ==

                                                perm).scalar()

                    self.sa.add(r2p)

                else:

                    g2p = self.sa.query(UsersGroupRepoToPerm)\

                            .filter(UsersGroupRepoToPerm.users_group ==

                                    UsersGroup.get_by_group_name(member))\

                            .filter(UsersGroupRepoToPerm.repository ==

            self.sa.delete(obj)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

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

 == form_data['users_group_id']).one()

            self.sa.delete(obj)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete_stats(self, repo_name):

        try:

            obj = self.sa.query(Statistics)\

                    .filter(Statistics.repository == \

        makes repository on filesystem. It's group aware means it'll create

        a repository within a group, and alter the paths accordingly of

        group location

        :param repo_name:

        :param alias:

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

        # check if this path is not a repository

        if is_valid_repo(repo_path, self.repos_path):

            raise Exception('This path %s is a valid repository' % repo_path)

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

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

        permission = Permission.get_by_key(permission)

        current = self.get_user_permission(repository, user)

        if current:

            if not current.permission is permission:

                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)

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

from rhodecode.lib import helpers as h

from rhodecode.lib import safe_str

from rhodecode.lib.auth import HasRepoPermissionAny

from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \

    action_logger, EmptyChangeset