# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from formencode import htmlfill

from operator import itemgetter

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from pylons_app.lib import helpers as h

from pylons_app.lib.auth import LoginRequired, HasPermissionAllDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import invalidate_cache

from pylons_app.model.forms import RepoForm

from pylons_app.model.hg_model import HgModel

from pylons_app.model.repo_model import RepoModel

import formencode

import logging

log = logging.getLogger(__name__)

class ReposController(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('repo', 'repos')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        c.admin_user = session.get('admin_user')

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

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

        # url('repos')

        cached_repo_list = HgModel().get_repos()

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

        return render('admin/repos/repos.html')

    def create(self):

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

        # url('repos')

        repo_model = RepoModel()

        _form = RepoForm()()

        try:

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

            repo_model.create(form_result, c.hg_app_user)

            invalidate_cache('cached_repo_list')

            h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

        except formencode.Invalid as errors:

            c.new_repo = errors.value['repo_name']

            return htmlfill.render(

                defaults=errors.value,

        except Exception:

        return redirect('repos')

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

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

        new_repo = request.GET.get('repo', '')

        c.new_repo = h.repo_name_slug(new_repo)

        return render('admin/repos/repo_add.html')

    def update(self, repo_name):

        """PUT /repos/repo_name: 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('repo', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('cached_repo_list')

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

                    category='success')

        except formencode.Invalid as errors:

            c.repo_info = repo_model.get(repo_name)

            c.users_array = repo_model.get_users_js()

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

            return htmlfill.render(

                defaults=errors.value,

                encoding="UTF-8")

        except Exception:

            h.flash(_('error occured during update of repository %s') \

    def delete(self, repo_name):

        """DELETE /repos/repo_name: 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('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get(repo_name)

#!/usr/bin/env python

# encoding: utf-8

# settings controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

# 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from formencode import htmlfill

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from pylons_app.lib.auth import LoginRequired, HasRepoPermissionAllDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import invalidate_cache

from pylons_app.model.forms import RepoSettingsForm

from pylons_app.model.repo_model import RepoModel

import formencode

import logging

import pylons_app.lib.helpers as h

log = logging.getLogger(__name__)

class SettingsController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAllDecorator('repository.admin')           

    def __before__(self):

        super(SettingsController, self).__before__()

    def index(self, repo_name):

        repo_model = RepoModel()

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

            defaults.update({'perm_%s' % p.user.username: 

                             p.permission.permission_name})

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )  

    def update(self, repo_name):

        repo_model = RepoModel()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('cached_repo_list')

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

                    category='success')

        except formencode.Invalid as errors:

            c.repo_info = repo_model.get(repo_name)

            c.users_array = repo_model.get_users_js()

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

            return htmlfill.render(

                defaults=errors.value,

        except Exception:

            h.flash(_('error occured during update of repository %s') \

                    % form_result['repo_name'], category='error')

                else:

                    log.warning('user %s not authenticated', username)

                    raise formencode.Invalid(self.message('invalid_password',

                                             state=State_obj), value, state,

                                             error_dict=self.e_dict)

            else:

                log.warning('user %s is disabled', username)

                raise formencode.Invalid(self.message('disabled_account',

                                         state=State_obj),

                                         value, state,

                                         error_dict=self.e_dict_disable)

class ValidRepoUser(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        sa = meta.Session

        try:

            self.user_db = sa.query(User)\

                .filter(User.active == True)\

                .filter(User.username == value).one()

        except Exception:

            raise formencode.Invalid(_('This username is not valid'),

                                     value, state)

        return self.user_db.user_id

    class _ValidRepoName(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            slug = h.repo_name_slug(value)

            if slug in ['_admin']:

                raise formencode.Invalid(_('This repository name is disallowed'),

                                         value, state)

            return slug 

    return _ValidRepoName

class ValidPerms(formencode.validators.FancyValidator):

    messages = {'perm_new_user_name':_('This username is not valid')}

    def to_python(self, value, state):

        perms_update = []

        perms_new = []

        #build a list of permission to update and new permission to create

        for k, v in value.items():

            if k.startswith('perm_'):

                if  k.startswith('perm_new_user'):

        if edit:

            new_password = All(UnicodeString(strip=True, min=3, not_empty=False), ValidPassword)

            admin = StringBoolean(if_missing=False)

        else:

            password = All(UnicodeString(strip=True, min=3, not_empty=False), ValidPassword)

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=3, not_empty=True)

        lastname = UnicodeString(strip=True, min=3, not_empty=True)

        email = Email(not_empty=True)

    return _UserForm

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

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

        private = StringBoolean(if_missing=False)

        if edit:

            user = All(Int(not_empty=True), ValidRepoUser)

        chained_validators = [ValidPerms]

    return _RepoForm

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

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

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidPerms, ValidSettings]

    return _RepoForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        app_title = UnicodeString(strip=True, min=3, not_empty=True)

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

        u_tmpl = '''{id:%s, fname:"%s", lname:"%s", nname:"%s"},'''

        users_array = '[%s];' % '\n'.join([u_tmpl % (u.user_id, u.name,

                                                    u.lastname, u.username) 

                                        for u in users])

        return users_array        

    def update(self, repo_id, form_data):

        try:

            if repo_id != form_data['repo_name']:

                self.__rename_repo(repo_id, form_data['repo_name'])

            cur_repo = self.sa.query(Repository).get(repo_id)

            for k, v in form_data.items():

                if k == 'user':

                    cur_repo.user_id = v

                else:

                    setattr(cur_repo, k, v)

            #update permissions

            for username, perm in form_data['perms_updates']:

                r2p = self.sa.query(Repo2Perm)\

                        .filter(Repo2Perm.user == self.sa.query(User)\

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def __create_repo(self, repo_name):        

        repo_path = os.path.join(g.base_path, repo_name)

        if check_repo(repo_name, g.base_path):

            log.info('creating repo %s in %s', repo_name, repo_path)

            from vcs.backends.hg import MercurialRepository

            MercurialRepository(repo_path, create=True)

    def __rename_repo(self, old, new):

        old_path = os.path.join(g.base_path, old)

        new_path = os.path.join(g.base_path, new)

        shutil.move(old_path, new_path)

    def __delete_repo(self, name):

        rm_path = os.path.join(g.base_path, name)

        log.info("Removing %s", rm_path)

        #disable hg 

        shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))

        #disable repo

        shutil.move(rm_path, os.path.join(g.base_path, 'rm__%s__%s' \

                                          % (datetime.today(), name)))