action="update_perm", conditions=dict(method=["PUT"]))

    #ADMIN USERS REST ROUTES

    #ADMIN GROUP REST ROUTES

    rmap.resource('group', 'groups',

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import UserForm, UsersGroupForm

from rhodecode.model.users_group import UsersGroupModel

log = logging.getLogger(__name__)

                    category='success')

            #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users_groups/users_group_edit.html'),

                defaults=errors.value,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

        c.available_members = [(x.user_id, x.username) for x in

                               self.sa.query(User).all()]

        defaults = c.users_group.get_dict()

        return htmlfill.render(

            render('admin/users_groups/users_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    UsersGroupMember().__table__.create()

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

    # Add table `users_group_to_perm`

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

    from rhodecode.model.db import UsersGroupToPerm

    UsersGroupToPerm().__table__.create()

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

    # Upgrade of `users` table

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

log = logging.getLogger(__name__)

def init_model(engine):

    :param engine: engine to bind to

    """

    log.info("initializing db for %s", engine)

    meta.Base.metadata.bind = engine

class BaseModel(object):

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

    into instance of model

Beaker constructs.

"""

from beaker.exceptions import BeakerException

from sqlalchemy.orm.interfaces import MapperOption

from sqlalchemy.orm.query import Query

from sqlalchemy.sql import visitors

class CachingQuery(Query):

    """A Query subclass which optionally loads full results from a Beaker

        """

        if hasattr(self, '_cache_parameters'):

        else:

            return Query.__iter__(self)

        cache, cache_key = _get_cache_parameters(self)

        cache.put(cache_key, value)

def query_callable(manager):

    def query(*arg, **kw):

        return CachingQuery(manager, *arg, **kw)

    return query

def get_cache_region(name, region):

    if region not in beaker.cache.cache_regions:

        raise BeakerException('Cache region `%s` not configured '

    kw = beaker.cache.cache_regions[region]

    return beaker.cache.Cache._get_cache(name, kw)

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    return the correspoinding Cache instance and cache key, based

    """

    if not hasattr(query, '_cache_parameters'):

    region, namespace, cache_key = query._cache_parameters

    return cache, cache_key

def _namespace_from_query(namespace, query):

    # cache namespace - the token handed in by the

    # option + class we're querying against

    return namespace

def _set_cache_parameters(query, region, namespace, cache_key):

    if hasattr(query, '_cache_parameters'):

                    )

    query._cache_parameters = region, namespace, cache_key

class FromCache(MapperOption):

    """Specifies that a Query should load results from a cache."""

    def process_query(self, query):

        """Process a Query during normal loading operation."""

class RelationshipCache(MapperOption):

    """Specifies that a Query as called within a "lazy load"

        self.region = region

        self.namespace = namespace

        self._relationship_options = {

        }

    def process_query_conditionally(self, query):

            for cls in mapper.class_.__mro__:

                if (cls, key) in self._relationship_options:

                    _set_cache_parameters(

                            query,

                            relationship_option.region,

    """

    v = []

    def visit_bindparam(bind):

        value = query._params.get(bind.key, bind.value)

        v.append(value)

    if query._criterion is not None:

    return v

    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")

class UsersGroupMember(Base):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'useexisting':True}

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

    group = relationship('Group')

    repo_to_perm = relationship('RepoToPerm', cascade='all', order_by='RepoToPerm.repo_to_perm_id')

    stats = relationship('Statistics', cascade='all', uselist=False)

    followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')

        except:

            Session.rollback()

    __table_args__ = (UniqueConstraint('users_group_id', 'permission_id'), {'useexisting':True})

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission = relationship('Permission')

    repository = relationship('Repository')

class GroupToPerm(Base):

    __tablename__ = 'group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'useexisting':True})

from rhodecode.model import meta

from rhodecode.model.user import UserModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import User, UsersGroup

from rhodecode import BACKENDS

class State_obj(object):

    _ = staticmethod(_)

# VALIDATORS

class ValidAuthToken(formencode.validators.FancyValidator):

    messages = {'invalid_token':_('Token mismatch')}

            if old_un != value or not edit:

                if UserModel().get_by_username(value, cache=False,

                                               case_insensitive=True):

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                raise formencode.Invalid(_('Username may only contain '

    return _ValidUsername

def ValidUsersGroup(edit, old_data):

    class _ValidUsersGroup(formencode.validators.FancyValidator):

            #check if group is unique

            old_ugname = None

            if edit:

            if old_ugname != value or not edit:

                                               case_insensitive=True):

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                raise formencode.Invalid(_('Group name may only contain '

    return _ValidUsersGroup

                )

          )

class BaseModel(object):

    """Base Model for all classess

    def update(self, form_result):

        perm_user = self.sa.query(User)\

        if len(u2p) != 3:

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

                            ' user. This should not happen please verify'

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

                self.sa.add(perm_user)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

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

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    @LazyProperty

                                          "get_repo_%s" % repo_id))

        return repo.scalar()

    def get_by_repo_name(self, repo_name, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name)

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_full(self, repo_name, cache=False, invalidate=False):

        repo = self.sa.query(Repository)\

            .options(joinedload(Repository.fork))\

                make_transient(attr)

        return ret

    def get_users_js(self):

        users = self.sa.query(User).filter(User.active == True).all()

                                        for u in users])

        return users_array

    def get_users_groups_js(self):

        users_groups = self.sa.query(UsersGroup)\

            .filter(UsersGroup.users_group_active == True).all()

        try:

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

            user_model = UserModel(self.sa)

            #update permissions

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

                if member_type == 'user':

                    r2p = self.sa.query(RepoToPerm)\

                            .filter(RepoToPerm.repository == cur_repo)\

                            .one()

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

                    self.sa.add(r2p)

                else:

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

                    self.sa.add(g2p)

            #set new permissions

                    r2p.user = user_model.get_by_username(member)

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

                    self.sa.add(r2p)

                else:

                    g2p.repository = cur_repo

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

                    self.sa.add(g2p)

            #update current repo

    def delete_perm_users_group(self, form_data, repo_name):

        try:

                        == self.get_by_repo_name(repo_name))\

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

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def __create_repo(self, repo_name, alias, clone_uri=False):

        """

        makes repository on filesystem

from rhodecode.model.caching_query import FromCache

from rhodecode.model.db import UsersGroup, UsersGroupMember

log = logging.getLogger(__name__)

        users_group = self.sa.query(UsersGroup)

        if cache:

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

        return users_group.get(users_group_id)

    def create(self, form_data):

        try:

            new_users_group = UsersGroup()

                    members_list = []

                    if v:

                        for u_id in set(v):

                    setattr(users_group, 'members', members_list)

                setattr(users_group, k, v)

    <div class="title">

        <h5>${_('Permissions')}</h5>       

    </div>

    <div class="form">

        <!-- fields -->

        <div class="fields">

                    <label for="">${_('Create repositories')}:</label>

                </div>

                <div class="checkboxes">

                </div>

             </div>

            <div class="buttons">