# 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

import formencode

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

from pylons import request, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

                      ' in order to rescan repositories') % repo_name,

                      category='error')

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

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision

        else:

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

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

                                            c.repo_last_rev) * 100)

        return defaults

    @HasPermissionAllDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

import traceback

import logging

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.model.scm import ScmModel

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

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.repo_permission import RepositoryPermissionModel

                                name = repository.repo_name,

                                type = repository.repo_type,

                                description = repository.description))

        return result

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

        """

        Create a repository

        :param apiuser

        :param name

        :param description

            try:

                user = User.get_by_username(user_name)

            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'

                            % dict(user = user_name, repo = repo_name))

    HasRepoPermissionAnyDecorator, NotAnonymous

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

class SettingsController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasRepoPermissionAllDecorator('repository.admin')

    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:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user': c.repo_info.user.username})

import logging

import datetime

import traceback

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

from vcs.utils.helpers import get_scm

from vcs.exceptions import VCSError

from vcs.utils.lazy import LazyProperty

    @classmethod

    def query(cls):

        return Session.query(cls)

    @classmethod

    def get(cls, id_):

        return cls.query().get(id_)

    @classmethod

    def getAll(cls):

        return cls.query().all()

    @property

    def name(self):

        return self.group_name.split(Group.url_sep())[-1]

    @property

    def full_path(self):

    @property

    def full_path_splitted(self):

        return self.group_name.split(Group.url_sep())

    @property

    def get_new_name(self, group_name):

        """

        returns new full group name based on parent and new name

        :param group_name:

        """

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

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

    __table_args__ = {'extend_existing':True}

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = {'extend_existing':True}

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

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

class ValidAuth(formencode.validators.FancyValidator):

    messages = {

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

    e_dict_disable = {'username':messages['disabled_account']}

    def validate_python(self, value, state):

                gr = Group.get(value.get('repo_group'))

                group_path = gr.full_path

                # value needs to be aware of group name in order to check

                # 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

            value['repo_name_full'] = repo_name_full

        repo_type = All(ValidForkType(old_data), OneOf(supported_backends))

        chained_validators = [ValidForkName()]

    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

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        users_groups_array = '[%s]' % '\n'.join([g_tmpl % \

                                    (gr.users_group_id, gr.users_group_name,

                                     len(gr.members))

                                        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)

            # update permissions

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

            for k, v in form_data.items():

                if k == 'user':

                    cur_repo.user = User.get_by_username(v)

                elif k == 'repo_name':

                    pass

                elif k == 'repo_group':

                else:

                    setattr(cur_repo, k, v)

            new_name = cur_repo.get_new_name(form_data['repo_name'])

            cur_repo.repo_name = new_name

                    os.path.join(rm_path, 'rm__.%s' % alias))

        #disable repo

        shutil.move(rm_path, os.path.join(self.repos_path, 'rm__%s__%s' \

                                          % (datetime.today()\

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

                                            repo.repo_name)))

        Get's the repositories root path from database

        """

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

        return q.ui_value

        """

        makes repositories group on filesystem

        :param repo_name:

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

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already '

                            'existing dir %s' % new_path)

        :param group: instance of group from database

        """

        paths = group.full_path.split(Group.url_sep())

        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

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def update(self, repos_group_id, form_data):

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

            raise

    def delete(self, users_group_id):

            raise

    def create_ldap(self, username, password, user_dn, attrs):

        """

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

        as ldap user

        :param username:

        :param password:

        :param user_dn:

        :param attrs:

        """

        from rhodecode.lib.auth import get_crypt_password

                # given from other sources

                if PERM_WEIGHTS[p] > PERM_WEIGHTS[cur_perm]:

                    user.permissions['repositories'][perm.UsersGroupRepoToPerm.

                                                     repository.repo_name] = p

        return user

                    <label for="repo_name">${_('Name')}:</label>

                </div>

                <div class="input input-medium">

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

                </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

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

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

            self.fail('could not login using %s %s' % (username, password))

        self.assertEqual(response.status, '302 Found')

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