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

# 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/>.

"""

kallithea.lib.middleware.pygrack

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

Python implementation of git-http-backend's Smart HTTP protocol

Based on original code from git_http_backend.py project.

Copyright (c) 2010 Daniel Dotsenko <dotsa@hotmail.com>

Copyright (c) 2012 Marcin Kuzminski <marcin@python-works.com>

This file was forked by the Kallithea project in July 2014.

"""

import logging

import os

import socket

import traceback

from dulwich.server import update_server_info

from dulwich.web import GunzipFilter, LimitedInputFilter

from webob import Request, Response, exc

import kallithea

from kallithea.lib.utils2 import ascii_bytes

log = logging.getLogger(__name__)

class FileWrapper(object):

    def __init__(self, fd, content_length):

        self.fd = fd

        self.content_length = content_length

        self.remain = content_length

    def read(self, size):

        if size <= self.remain:

            try:

                data = self.fd.read(size)

            except socket.error:

                raise IOError(self)

            self.remain -= size

        elif self.remain:

            data = self.fd.read(self.remain)

            self.remain = 0

        else:

            data = None

        return data

    def __repr__(self):

        return '<FileWrapper %s len: %s, read: %s>' % (

            self.fd, self.content_length, self.content_length - self.remain

        )

class GitRepository(object):

    git_folder_signature = set(['config', 'head', 'info', 'objects', 'refs'])

    commands = ['git-upload-pack', 'git-receive-pack']

    def __init__(self, repo_name, content_path):

        files = set([f.lower() for f in os.listdir(content_path)])

        if not (self.git_folder_signature.intersection(files)

                == self.git_folder_signature):

            raise OSError('%s missing git signature' % content_path)

        self.content_path = content_path

        self.valid_accepts = ['application/x-%s-result' %

                              c for c in self.commands]

        self.repo_name = repo_name

    def _get_fixedpath(self, path):

        """

        Small fix for repo_path

        :param path:

        """

        assert path.startswith('/' + self.repo_name + '/')

        return path[len(self.repo_name) + 2:].strip('/')

    def inforefs(self, req, environ):

        """

        WSGI Response producer for HTTP GET Git Smart

        HTTP /info/refs request.

        """

        git_command = req.GET.get('service')

        if git_command not in self.commands:

            log.debug('command %s not allowed', git_command)

            return exc.HTTPMethodNotAllowed()

        # From Documentation/technical/http-protocol.txt shipped with Git:

        #

        # Clients MUST verify the first pkt-line is `# service=$servicename`.

        # Servers MUST set $servicename to be the request parameter value.

        # Servers SHOULD include an LF at the end of this line.

        # Clients MUST ignore an LF at the end of the line.

        #

        #  smart_reply     =  PKT-LINE("# service=$servicename" LF)

        #                     ref_list

        #                     "0000"

        server_advert = '# service=%s\n' % git_command

        packet_len = hex(len(server_advert) + 4)[2:].rjust(4, '0').lower()

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        cmd = [_git_path, git_command[4:],

               '--stateless-rpc', '--advertise-refs', self.content_path]

        log.debug('handling cmd %s', cmd)

        try:

            out = subprocessio.SubprocessIOChunker(cmd,

                starting_values=[ascii_bytes(packet_len + server_advert + '0000')]

            )

        except EnvironmentError as e:

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        resp = Response()

        resp.content_type = 'application/x-%s-advertisement' % git_command

        resp.charset = None

        resp.app_iter = out

        return resp

    def backend(self, req, environ):

        """

        WSGI Response producer for HTTP POST Git Smart HTTP requests.

        Reads commands and data from HTTP POST's body.

        returns an iterator obj with contents of git command's

        response to stdout

        """

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        git_command = self._get_fixedpath(req.path_info)

        if git_command not in self.commands:

            log.debug('command %s not allowed', git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

            inputstream = FileWrapper(environ['wsgi.input'],

                                      req.content_length)

        else:

            inputstream = environ['wsgi.input']

        gitenv = dict(os.environ)

        # forget all configs

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        cmd = [_git_path, git_command[4:], '--stateless-rpc', self.content_path]

        log.debug('handling cmd %s', cmd)

        try:

            out = subprocessio.SubprocessIOChunker(

                cmd,

                inputstream=inputstream,

                env=gitenv,

                cwd=self.content_path,

            )

        except EnvironmentError as e:

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        if git_command in ['git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

        resp = Response()

        resp.content_type = 'application/x-%s-result' % git_command

        resp.charset = None

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):

        req = Request(environ)

        _path = self._get_fixedpath(req.path_info)

        if _path.startswith('info/refs'):

            app = self.inforefs

        elif req.accept.acceptable_offers(self.valid_accepts):

            app = self.backend

        try:

            resp = app(req, environ)

        except exc.HTTPException as e:

            resp = e

            log.error(traceback.format_exc())

        except Exception as e:

            log.error(traceback.format_exc())

            resp = exc.HTTPInternalServerError()

        return resp(environ, start_response)

class GitDirectory(object):

    def __init__(self, repo_root, repo_name):

        repo_location = os.path.join(repo_root, repo_name)

        if not os.path.isdir(repo_location):

            raise OSError(repo_location)

        self.content_path = repo_location

        self.repo_name = repo_name

        self.repo_location = repo_location

    def __call__(self, environ, start_response):

        content_path = self.content_path

        try:

            app = GitRepository(self.repo_name, content_path)

        except (AssertionError, OSError):

            content_path = os.path.join(content_path, '.git')

            if os.path.isdir(content_path):

                app = GitRepository(self.repo_name, content_path)

            else:

                return exc.HTTPNotFound()(environ, start_response)

        return app(environ, start_response)

def make_wsgi_app(repo_name, repo_root):

    app = GitDirectory(repo_root, repo_name)

    return GunzipFilter(LimitedInputFilter(app))

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

# 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/>.

"""

kallithea.controllers.admin.settings

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

settings controller for Kallithea admin

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jul 14, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import config, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.celerylib import tasks

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs import VCSError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class SettingsController(BaseController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(SettingsController, self)._before(*args, **kwargs)

    def _get_hg_ui_settings(self):

        ret = db.Ui.query().all()

        settings = {}

        for each in ret:

            k = each.ui_section + '_' + each.ui_key

            v = each.ui_value

            if k == 'paths_/':

                k = 'paths_root_path'

            k = k.replace('.', '_')

            if each.ui_section in ['hooks', 'extensions']:

                v = each.ui_active

            settings[k] = v

        return settings

    @HasPermissionAnyDecorator('hg.admin')

    def settings_vcs(self):

        c.active = 'vcs'

        if request.POST:

            application_form = ApplicationUiSettingsForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

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

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8",

                     force_defaults=False)

            try:

                if c.visual.allow_repo_location_change:

                    sett = db.Ui.get_by_key('paths', '/')

                    sett.ui_value = form_result['paths_root_path']

                # HOOKS

                sett = db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE)

                sett.ui_active = form_result['hooks_changegroup_update']

                sett = db.Ui.get_by_key('hooks', db.Ui.HOOK_REPO_SIZE)

                sett.ui_active = form_result['hooks_changegroup_repo_size']

                ## EXTENSIONS

                sett = db.Ui.get_or_create('extensions', 'largefiles')

                sett.ui_active = form_result['extensions_largefiles']

#                sett = db.Ui.get_or_create('extensions', 'hggit')

#                sett.ui_active = form_result['extensions_hggit']

                meta.Session().commit()

                webutils.flash(_('Updated VCS settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                webutils.flash(_('Error occurred while updating '

                          'application settings'), category='error')

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_mapping(self):

        c.active = 'mapping'

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

            install_git_hooks = request.POST.get('hooks', False)

            overwrite_git_hooks = request.POST.get('hooks_overwrite', False)

            invalidate_cache = request.POST.get('invalidate', False)

            log.debug('rescanning repo location with destroy obsolete=%s, '

                      'install git hooks=%s and '

                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()

            added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,

                                            install_git_hooks=install_git_hooks,

                                            user=request.authuser.username,

                                            overwrite_git_hooks=overwrite_git_hooks)

            added_msg = webutils.HTML(', ').join(

                webutils.link_to(safe_str(repo_name), webutils.url('summary_home', repo_name=repo_name)) for repo_name in added

            ) or '-'

            removed_msg = webutils.HTML(', ').join(

                safe_str(repo_name) for repo_name in removed

            ) or '-'

            webutils.flash(webutils.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %

                    (added_msg, removed_msg), category='success')

            if invalidate_cache:

                log.debug('invalidating all repositories cache')

                i = 0

                for repo in db.Repository.query():

                    try:

                        ScmModel().mark_for_invalidation(repo.repo_name)

                        i += 1

                    except VCSError as e:

                        log.warning('VCS error invalidating %s: %s', repo.repo_name, e)

                webutils.flash(_('Invalidated %s repositories') % i, category='success')

            raise HTTPFound(location=url('admin_settings_mapping'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_global(self):

        c.active = 'global'

        if request.POST:

            application_form = ApplicationSettingsForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

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

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            try:

                for setting in (

                    'title',

                    'realm',

                    'ga_code',

                    'captcha_public_key',

                    'captcha_private_key',

                ):

                    db.Setting.create_or_update(setting, form_result[setting])

                meta.Session().commit()

                set_app_settings(config)

                webutils.flash(_('Updated application settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                webutils.flash(_('Error occurred while updating '

                          'application settings'),

                          category='error')

            raise HTTPFound(location=url('admin_settings_global'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_visual(self):

        c.active = 'visual'

        if request.POST:

            application_form = ApplicationVisualisationForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

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

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            try:

                settings = [

                    ('show_public_icon', 'show_public_icon', 'bool'),

                    ('show_private_icon', 'show_private_icon', 'bool'),

                    ('stylify_metalabels', 'stylify_metalabels', 'bool'),

                    ('repository_fields', 'repository_fields', 'bool'),

                    ('dashboard_items', 'dashboard_items', 'int'),

                    ('admin_grid_items', 'admin_grid_items', 'int'),

                    ('show_version', 'show_version', 'bool'),

                    ('use_gravatar', 'use_gravatar', 'bool'),

                    ('gravatar_url', 'gravatar_url', 'unicode'),

                    ('clone_uri_tmpl', 'clone_uri_tmpl', 'unicode'),

                    ('clone_ssh_tmpl', 'clone_ssh_tmpl', 'unicode'),

                ]

                for setting, form_key, type_ in settings:

                    db.Setting.create_or_update(setting, form_result[form_key], type_)

                meta.Session().commit()

                set_app_settings(config)

                webutils.flash(_('Updated visualisation settings'),

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                webutils.flash(_('Error occurred during updating '

                          'visualisation settings'),

                        category='error')

            raise HTTPFound(location=url('admin_settings_visual'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_email(self):

        c.active = 'email'

        if request.POST:

            test_email = request.POST.get('test_email')

            test_email_subj = 'Kallithea test email'

            test_body = ('Kallithea Email test, '

                               'Kallithea version: %s' % c.kallithea_version)

            if not test_email:

                webutils.flash(_('Please enter email address'), category='error')

                raise HTTPFound(location=url('admin_settings_email'))

            test_email_txt_body = EmailNotificationModel() \

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                'txt', body=test_body)

            test_email_html_body = EmailNotificationModel() \

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                'html', body=test_body)

            recipients = [test_email] if test_email else None

            tasks.send_email(recipients, test_email_subj,

                             test_email_txt_body, test_email_html_body)

            webutils.flash(_('Send email task created'), category='success')

            raise HTTPFound(location=url('admin_settings_email'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_hooks(self):

        c.active = 'hooks'

        if request.POST:

            if c.visual.allow_custom_hooks_settings:

                ui_key = request.POST.get('new_hook_ui_key')

                ui_value = request.POST.get('new_hook_ui_value')

                hook_id = request.POST.get('hook_id')

                try:

                    ui_key = ui_key and ui_key.strip()

                    if ui_key in (x.ui_key for x in db.Ui.get_custom_hooks()):

                        webutils.flash(_('Hook already exists'), category='error')

                    elif ui_key in (x.ui_key for x in db.Ui.get_builtin_hooks()):

                        webutils.flash(_('Builtin hooks are read-only. Please use another hook name.'), category='error')

                    elif ui_value and ui_key:

                        db.Ui.create_or_update_hook(ui_key, ui_value)

                        webutils.flash(_('Added new hook'), category='success')

                    elif hook_id:

                        db.Ui.delete(hook_id)

                        meta.Session().commit()

                    # check for edits

                    update = False

                    _d = request.POST.dict_of_lists()

                    for k, v, ov in zip(_d.get('hook_ui_key', []),

                                        _d.get('hook_ui_value_new', []),

                                        _d.get('hook_ui_value', [])):

                        if v != ov:

                            db.Ui.create_or_update_hook(k, v)

                            update = True

                    if update:

                        webutils.flash(_('Updated hooks'), category='success')

                    meta.Session().commit()

                except Exception:

                    log.error(traceback.format_exc())

                    webutils.flash(_('Error occurred during hook creation'),

                            category='error')

                raise HTTPFound(location=url('admin_settings_hooks'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.hooks = db.Ui.get_builtin_hooks()

        c.custom_hooks = db.Ui.get_custom_hooks()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_search(self):

        c.active = 'search'

        if request.POST:

            repo_location = self._get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index', False)

            tasks.whoosh_index(repo_location, full_index)

            webutils.flash(_('Whoosh reindex task scheduled'), category='success')

            raise HTTPFound(location=url('admin_settings_search'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_system(self):

        c.active = 'system'

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        server_info = db.Setting.get_server_info()

        for key, val in server_info.items():

            setattr(c, key, val)

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

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

# 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/>.

"""

kallithea.controllers.login

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

Login controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 22, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import re

import formencode

from formencode import htmlfill

from tg import request, session

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, log_in_user, render

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import LoginForm, PasswordResetConfirmationForm, PasswordResetRequestForm, RegisterForm

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def _validate_came_from(self, came_from,

            _re=re.compile(r"/(?!/)[-!#$%&'()*+,./:;=?@_~0-9A-Za-z]*$")):

        """Return True if came_from is valid and can and should be used.

        Determines if a URI reference is valid and relative to the origin;

        or in RFC 3986 terms, whether it matches this production:

          origin-relative-ref = path-absolute [ "?" query ] [ "#" fragment ]

        with the exception that '%' escapes are not validated and '#' is

        allowed inside the fragment part.

        """

        return _re.match(came_from) is not None

    def index(self):

        c.came_from = request.GET.get('came_from', '')

        if c.came_from:

            if not self._validate_came_from(c.came_from):

                log.error('Invalid came_from (not server-relative): %r', c.came_from)

                raise HTTPBadRequest()

        else:

            c.came_from = url('home')

        if request.POST:

            # import Login Form validator class

            login_form = LoginForm()()

            try:

                # login_form will check username/password using ValidAuth and report failure to the user

                c.form_result = login_form.to_python(dict(request.POST))

                username = c.form_result['username']

                user = db.User.get_by_username_or_email(username)

                assert user is not None  # the same user get just passed in the form validation

            except formencode.Invalid as errors:

                defaults = errors.value

                # remove password from filling in form again

                defaults.pop('password', None)

                return htmlfill.render(

                    render('/login.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except UserCreationError as e:

                # container auth or other auth functions that create users on

                # the fly can throw this exception signaling that there's issue

                # with user creation, explanation should be provided in

                # Exception itself

                webutils.flash(e, 'error')

            else:

                # login_form already validated the password - now set the session cookie accordingly

                auth_user = log_in_user(user, c.form_result['remember'], is_external_auth=False, ip_addr=request.ip_addr)

                if auth_user:

                    raise HTTPFound(location=c.came_from)

                webutils.flash(_('Authentication failed.'), 'error')

        else:

            # redirect if already logged in

            if not request.authuser.is_anonymous:

                raise HTTPFound(location=c.came_from)

            # continue to show login to default user

        return render('/login.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        def_user_perms = AuthUser(dbuser=db.User.get_default_user()).global_permissions

        c.auto_active = 'hg.register.auto_activate' in def_user_perms

        settings = db.Setting.get_app_settings()

        captcha_private_key = settings.get('captcha_private_key')

        c.captcha_active = bool(captcha_private_key)

        c.captcha_public_key = settings.get('captcha_public_key')

        if request.POST:

            register_form = RegisterForm()()

            try:

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

                form_result['active'] = c.auto_active

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

                    if not response.is_valid:

                        _value = form_result

                        _msg = _('Bad captcha')

                        error_dict = {'recaptcha_field': _msg}

                        raise formencode.Invalid(_msg, _value, None,

                                                 error_dict=error_dict)

                UserModel().create_registration(form_result)

                webutils.flash(_('You have successfully registered with %s') % (c.site_name or 'Kallithea'),

                        category='success')

                meta.Session().commit()

                raise HTTPFound(location=url('login_home'))

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('/register.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except UserCreationError as e:

                # container auth or other auth functions that create users on

                # the fly can throw this exception signaling that there's issue

                # with user creation, explanation should be provided in

                # Exception itself

                webutils.flash(e, 'error')

        return render('/register.html')

    def password_reset(self):

        settings = db.Setting.get_app_settings()

        captcha_private_key = settings.get('captcha_private_key')

        c.captcha_active = bool(captcha_private_key)

        c.captcha_public_key = settings.get('captcha_public_key')

        if request.POST:

            password_reset_form = PasswordResetRequestForm()()

            try:

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

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

                    if not response.is_valid:

                        _value = form_result

                        _msg = _('Bad captcha')

                        error_dict = {'recaptcha_field': _msg}

                        raise formencode.Invalid(_msg, _value, None,

                                                 error_dict=error_dict)

                redirect_link = UserModel().send_reset_password_email(form_result)

                webutils.flash(_('A password reset confirmation code has been sent'),

                            category='success')

                raise HTTPFound(location=redirect_link)

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('/password_reset.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

        return render('/password_reset.html')

    def password_reset_confirmation(self):

        # This controller handles both GET and POST requests, though we

        # only ever perform the actual password change on POST (since

        # GET requests are not allowed to have side effects, and do not

        # receive automatic CSRF protection).

        # The template needs the email address outside of the form.

        c.email = request.params.get('email')

        c.timestamp = request.params.get('timestamp') or ''

        c.token = request.params.get('token') or ''

        if not request.POST:

            return render('/password_reset_confirmation.html')