#ADMIN DEFAULTS REST ROUTES

    rmap.resource('default', 'defaults',

                  controller='admin/defaults', path_prefix=ADMIN_PREFIX)

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.defaults

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    default settings controller for Rhodecode

    :created_on: Apr 27, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# 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

import traceback

import formencode

from formencode import htmlfill

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import DefaultsForm

from rhodecode.model.meta import Session

from rhodecode import BACKENDS

from rhodecode.model.db import RhodeCodeSetting

log = logging.getLogger(__name__)

class DefaultsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('default', 'defaults')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        super(DefaultsController, self).__before__()

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

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

        # url('defaults')

        c.backends = BACKENDS.keys()

        defaults = RhodeCodeSetting.get_default_repo_settings()

        return htmlfill.render(

            render('admin/defaults/defaults.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def create(self):

        """POST /defaults: Create a new item"""

        # url('defaults')

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

        """GET /defaults/new: Form to create a new item"""

        # url('new_default')

    def update(self, id):

        """PUT /defaults/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('default', id=ID),

        #           method='put')

        # url('default', id=ID)

        _form = DefaultsForm()()

        try:

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

            for k, v in form_result.iteritems():

                setting = RhodeCodeSetting.get_by_name_or_create(k)

                setting.app_settings_value = v

                Session().add(setting)

            Session().commit()

            h.flash(_('Default settings updated successfully'),

                    category='success')

        except formencode.Invalid, errors:

            defaults = errors.value

            return htmlfill.render(

                render('admin/defaults/defaults.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of defaults'),

                    category='error')

        return redirect(url('defaults'))

    def delete(self, id):

        """DELETE /defaults/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('default', id=ID),

        #           method='delete')

        # url('default', id=ID)

    def show(self, id, format='html'):

        """GET /defaults/id: Show a specific item"""

        # url('default', id=ID)

    def edit(self, id, format='html'):

        """GET /defaults/id/edit: Form to edit an existing item"""

        # url('edit_default', id=ID)

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\

    RhodeCodeSetting

        ## apply the defaults from defaults page

        defaults = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        return htmlfill.render(

            render('admin/repos/repo_add_create_repository.html'),

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8"

        )

                self.klass.create_default_options(skip_existing=True)

    def create_default_options(self, skip_existing=False):

        """Creates default settings"""

        for k, v in [

            ('default_repo_enable_locking',  False),

            ('default_repo_enable_downloads', False),

            ('default_repo_enable_statistics', False),

            ('default_repo_private', False),

            ('default_repo_type', 'hg')]:

            if skip_existing and RhodeCodeSetting.get_by_name(k) != None:

                log.debug('Skipping option %s' % k)

                continue

            setting = RhodeCodeSetting(k, v)

            self.sa.add(setting)

        self.create_default_options()

        s = s[len(prefix):]

    safe_unicode, remove_suffix, remove_prefix

        if self.app_settings_name in ["ldap_active",

                                      "default_repo_enable_statistics",

                                      "default_repo_enable_locking",

                                      "default_repo_private",

                                      "default_repo_enable_downloads"]:

    @classmethod

    def get_default_repo_settings(cls, cache=False, strip_prefix=False):

        ret = cls.query()\

                .filter(cls.app_settings_name.startswith('default_')).all()

        fd = {}

        for row in ret:

            key = row.app_settings_name

            if strip_prefix:

                key = remove_prefix(key, prefix='default_')

            fd.update({key: row.app_settings_value})

        return fd

        filter_extra_fields = True

        repo_description = v.UnicodeString(strip=True, min=1, not_empty=False)

        repo_private = v.StringBoolean(if_missing=False)

        repo_enable_statistics = v.StringBoolean(if_missing=False)

        repo_enable_downloads = v.StringBoolean(if_missing=False)

        repo_enable_locking = v.StringBoolean(if_missing=False)

        repo_landing_rev = v.OneOf(landing_revs, hideList=True)

        clone_uri = All(v.UnicodeString(strip=True, min=1, not_empty=False))

def RepoSettingsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

                     repo_groups=[], landing_revs=[]):

def DefaultPermissionsForm(repo_perms_choices, group_perms_choices,

                           register_choices, create_choices, fork_choices):

def DefaultsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):

    class _DefaultsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        default_repo_type = v.OneOf(supported_backends)

        default_repo_private = v.StringBoolean(if_missing=False)

        default_repo_enable_statistics = v.StringBoolean(if_missing=False)

        default_repo_enable_downloads = v.StringBoolean(if_missing=False)

        default_repo_enable_locking = v.StringBoolean(if_missing=False)

    return _DefaultsForm

    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, RepoGroup,\

    RhodeCodeSetting

                    copy_fork_permissions=False, enable_statistics=False,

                    enable_locking=False, enable_downloads=False):

            new_repo.enable_statistics = enable_statistics

            new_repo.enable_locking = enable_locking

            new_repo.enable_downloads = enable_downloads

        owner = cur_user

        description = form_data['repo_description']

        private = form_data['repo_private']

        landing_rev = form_data['repo_landing_rev']

        ##defaults

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        enable_statistics = defs.get('repo_enable_statistic')

        enable_locking = defs.get('repo_enable_locking')

        enable_downloads = defs.get('repo_enable_downloads')

            repos_group, landing_rev, just_db, fork_of, copy_fork_permissions,

            enable_statistics, enable_locking, enable_downloads

#header #header-inner #quick li ul li a.defaults,#header #header-inner #quick li ul li a.defaults:hover

    {

    background: #FFF url("../images/icons/wrench.png") no-repeat 4px 9px;

    width: 167px;

    margin: 0;

    padding: 12px 9px 7px 24px;

}

## -*- coding: utf-8 -*-

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Repositories defaults')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))}

    »

    ${_('Defaults')}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <h3>${_('Repositories defaults')}</h3>

    ${h.form(url('default', id='defaults'),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="default_repo_type">${_('Type')}:</label>

                </div>

                <div class="input">

                    ${h.select('default_repo_type','hg',c.backends,class_="medium")}

                </div>

            </div>        

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_private">${_('Private repository')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_private',value="True")}

                    <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_statistics">${_('Enable statistics')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_statistics',value="True")}

                    <span class="help-block">${_('Enable statistics window on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_downloads">${_('Enable downloads')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_downloads',value="True")}

                    <span class="help-block">${_('Enable download menu on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="default_repo_enable_locking">${_('Enable locking')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('default_repo_enable_locking',value="True")}

                    <span class="help-block">${_('Enable lock-by-pulling on repository.')}</span>

                </div>

            </div>

            <div class="buttons">

            ${h.submit('save',_('Save'),class_="ui-btn large")}

            </div>

        </div>

    </div>

    ${h.end_form()}

    ##<h3>${_('Groups defaults')}</h3>

</div>

</%def>

                %endif                

                <label for="repo_landing_rev">${_('Landing revision')}:</label>

                ${h.select('repo_landing_rev','',c.landing_revs,class_="medium")}

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

                ${h.textarea('repo_description')}

                <label for="repo_private">${_('Private repository')}:</label>

                ${h.checkbox('repo_private',value="True")}

                            <li>${h.link_to(_('defaults'),h.url('defaults'),class_='defaults')}</li>

    'GIT_REMOTE_REPO', 'SCM_TESTS', '_get_repo_create_params'

## HELPERS ##

def _get_repo_create_params(**custom):

    defs = {

        'repo_name': None,

        'repo_type': 'hg',

        'clone_uri': '',

        'repo_group': '',

        'repo_description': 'DESC',

        'repo_private': False,

        'repo_landing_rev': 'tip'

    }

    defs.update(custom)

    if 'repo_name_full' not in custom:

        defs.update({'repo_name_full': defs['repo_name']})

    return defs

    form_data = _get_repo_create_params(

                    repo_name_full=repo_name,

                    repo_description='description %s' % repo_name,

                )

from rhodecode.tests import *

from rhodecode.model.db import RhodeCodeSetting

class TestDefaultsController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url('defaults'))

        response.mustcontain('default_repo_private')

        response.mustcontain('default_repo_enable_statistics')

        response.mustcontain('default_repo_enable_downloads')

        response.mustcontain('default_repo_enable_locking')

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_defaults', format='xml'))

    def test_create(self):

        response = self.app.post(url('defaults'))

    def test_new(self):

        response = self.app.get(url('new_default'))

    def test_new_as_xml(self):

        response = self.app.get(url('formatted_new_default', format='xml'))

    def test_update(self):

        self.log_user()

        params = {

            'default_repo_enable_locking': True,

            'default_repo_enable_downloads': True,

            'default_repo_enable_statistics': True,

            'default_repo_private': True,

            'default_repo_type': 'hg',

        }

        response = self.app.put(url('default', id='default'), params=params)

        self.checkSessionFlash(response, 'Default settings updated successfully')

        defs = RhodeCodeSetting.get_default_repo_settings()

        self.assertEqual(params, defs)

        params = {

            'default_repo_enable_locking': False,

            'default_repo_enable_downloads': False,

            'default_repo_enable_statistics': False,

            'default_repo_private': False,

            'default_repo_type': 'git',

        }

        response = self.app.put(url('default', id='default'), params=params)

        self.checkSessionFlash(response, 'Default settings updated successfully')

        defs = RhodeCodeSetting.get_default_repo_settings()

        self.assertEqual(params, defs)

    def test_update_browser_fakeout(self):

        response = self.app.post(url('default', id=1), params=dict(_method='put'))

    def test_delete(self):

        response = self.app.delete(url('default', id=1))

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('default', id=1), params=dict(_method='delete'))

    def test_show(self):

        response = self.app.get(url('default', id=1))

    def test_show_as_xml(self):

        response = self.app.get(url('formatted_default', id=1, format='xml'))

    def test_edit(self):

        response = self.app.get(url('edit_default', id=1))

    def test_edit_as_xml(self):

        response = self.app.get(url('formatted_edit_default', id=1, format='xml'))

        response = self.app.post(url('repos'), 

                        _get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_description=description))

        response = self.app.post(url('repos'),

                        _get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_description=description))

        response = self.app.post(url('repos'),

                        _get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_description=description,

                                                repo_group=gr.group_id,))

        response = self.app.post(url('repos'),

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        response = self.app.post(url('repos'),

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        response = self.app.post(url('repos'),

                        _get_repo_create_params(repo_private=False,

                                                repo_type='hg',

                                                repo_name=repo_name,

                                                repo_description=description))