import logging

import traceback

import formencode

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        return defaults

    @HasPermissionAllDecorator('hg.admin')

import logging

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.model.scm import ScmModel

from rhodecode.model.db import User, UsersGroup, Group, Repository

        return result

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

        """

        Create a repository

            except NoResultFound:

                raise JSONRPCError('unknown user %s' % user)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to edit permission %(repo)s for %(user)s'

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

    def __before__(self):

        super(SettingsController, self).__before__()

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        repo_model = RepoModel()

            return redirect(url('home'))

        return htmlfill.render(

            render('settings/repo_settings.html'),

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoSettingsForm(edit=True,

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully' % repo_name),

                    category='success')

            action_logger(self.rhodecode_user, 'user_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

from datetime import date

from sqlalchemy import *

from sqlalchemy.ext.hybrid import hybrid_property

from beaker.cache import cache_region, region_invalidate

from vcs import get_backend

    @classmethod

    def get(cls, id_):

        return cls.query().get(id_)

    @classmethod

    @property

    def full_path(self):

    @property

    def full_path_splitted(self):

        :param group_name:

        """

        return Group.url_sep().join(path_prefix + [group_name])

    repository_id = Column('repository_id', String(250), primary_key = True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

            'invalid_password':_('invalid password'),

            'invalid_login':_('invalid user name'),

            'disabled_account':_('Your account is disabled')

    #error mapping

    e_dict = {'username':messages['invalid_login'],

              'password':messages['invalid_password']}

                # db key This is an actual just the name to store in the

                # database

                repo_name_full = group_path + Group.url_sep() + repo_name

            else:

                group_path = ''

                repo_name_full = repo_name

    return _RepoForkForm

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        SlugifyName())

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

    return _RepoForm

                                        for gr in users_groups])

        return users_groups_array

    def update(self, repo_name, form_data):

        try:

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

                elif k == 'repo_name':

                    pass

                elif k == 'repo_group':

                else:

                    setattr(cur_repo, k, v)

                                          % (datetime.today()\

                                             .strftime('%Y%m%d_%H%M%S_%f'),

                                            repo.repo_name)))

        q = RhodeCodeUi.get_by_key('/').one()

        return q.ui_value

        """

        makes repositories group on filesystem

        :param parent_id:

        """

        log.debug('creating new group in %s', create_path)

        if os.path.isdir(create_path):

            raise Exception('That directory already exists !')

        os.makedirs(create_path)

        """

        Renames a group on filesystem

        :param group_name:

        """

        log.debug('renaming repos group from %s to %s', old, new)

        log.debug('renaming repos paths from %s to %s', old_path, new_path)

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

        os.rmdir(rm_path)

    def create(self, form_data):

        try:

            new_repos_group = Group()

            self.sa.add(new_repos_group)

            self.sa.commit()

            return new_repos_group

        try:

            repos_group = Group.get(repos_group_id)

            self.sa.add(repos_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

        """

        Checks if user is in database, if not creates this user marked

        as ldap user

        :param username:

        :param password:

        :param user_dn:

                                                     repository.repo_name] = p

        return user

                    ${h.text('repo_name',class_="small")}

                </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

        self.assertEqual(response.session['rhodecode_user'].username, username)

        return response.follow()

    def checkSessionFlash(self, response, msg):

        self.assertTrue('flash' in response.session)

        self.assertTrue(msg in response.session['flash'][0][1])