# 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.bin.vcs_hooks

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

Entry points for Kallithea hooking into Mercurial and Git.

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: Aug 6, 2010

:author: marcink

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

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

"""

import logging

import os

import sys

import mercurial.hg

import mercurial.scmutil

import paste.deploy

import kallithea

import kallithea.config.application

from kallithea.lib import hooks, webutils

from kallithea.lib.utils2 import HookEnvironmentError, ascii_str, get_hook_environment, safe_bytes, safe_str

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.helpers import get_scm_size

from kallithea.model import db

log = logging.getLogger(__name__)

def repo_size(ui, repo, hooktype=None, **kwargs):

    """Show size of Mercurial repository.

    """

    size_hg, size_root = get_scm_size('.hg', safe_str(repo.root))

    last_cs = repo[len(repo) - 1]

    msg = ('Repository size .hg: %s Checkout: %s Total: %s\n'

           'Last revision is now r%s:%s\n') % (

        webutils.format_byte_size(size_hg),

        webutils.format_byte_size(size_root),

        webutils.format_byte_size(size_hg + size_root),

        last_cs.rev(),

        ascii_str(last_cs.hex())[:12],

    )

    ui.status(safe_bytes(msg))

def update(ui, repo, hooktype=None, **kwargs):

    """Update repo after push. The equivalent to 'hg update' but using the same

    Mercurial as everything else.

    """

    try:

        ui.pushbuffer(error=True, subproc=True)

        rev = brev = None

        mercurial.hg.updatetotally(ui, repo, rev, brev)

    finally:

        s = ui.popbuffer()  # usually just "x files updated, x files merged, x files removed, x files unresolved"

        log.info('%s update hook output: %s', safe_str(repo.root), safe_str(s).rstrip())

def pull_action(ui, repo, **kwargs):

    """Logs user pull action

    Called as Mercurial hook outgoing.kallithea_pull_action.

    """

    hooks.log_pull_action()

def push_action(ui, repo, node, node_last, **kwargs):

    """

    Register that changes have been added to the repo - log the action *and* invalidate caches.

    Note: This hook is not only logging, but also the side effect invalidating

    caches! The function should perhaps be renamed.

    Called as Mercurial hook changegroup.kallithea_push_action .

    The pushed changesets is given by the revset 'node:node_last'.

    """

    revs = [ascii_str(repo[r].hex()) for r in mercurial.scmutil.revrange(repo, [b'%s:%s' % (node, node_last)])]

    hooks.process_pushed_raw_ids(revs)

def _git_hook_environment(repo_path):

    """

    Create a light-weight environment for stand-alone scripts and return an UI and the

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    extras = get_hook_environment()

    path_to_ini_file = extras['config']

    config = paste.deploy.appconfig('config:' + path_to_ini_file)

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    kallithea.config.application.make_app(config.global_conf, **config.local_conf)

class SettingsController(base.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(

                     base.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 = db.Ui.get_by_key('hooks', db.Ui.HOOK_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(

            base.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

    @classmethod

    def get_auth_settings(cls):

        ret = cls.query() \

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

        fd = {}

        for row in ret:

            fd[row.app_settings_name] = row.app_settings_value

        return fd

    @classmethod

    def get_default_repo_settings(cls, 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

    @classmethod

    def get_server_info(cls):

        import platform

        import pkg_resources

        mods = [(p.project_name, p.version) for p in pkg_resources.working_set]

        info = {

            'modules': sorted(mods, key=lambda k: k[0].lower()),

            'py_version': platform.python_version(),

            'platform': platform.platform(),

            'kallithea_version': kallithea.__version__,

            'git_version': str(check_git_version()),

            'git_path': kallithea.CONFIG.get('git_path')

        }

        return info

class Ui(meta.Base, BaseDbModel):

    __tablename__ = 'ui'

    __table_args__ = (

        Index('ui_ui_section_ui_key_idx', 'ui_section', 'ui_key'),

        UniqueConstraint('ui_section', 'ui_key'),

        _table_args_default_dict,

    )

    ui_id = Column(Integer(), primary_key=True)

    ui_section = Column(String(255), nullable=False)

    ui_key = Column(String(255), nullable=False)

    ui_value = Column(String(255), nullable=True) # FIXME: not nullable?

    ui_active = Column(Boolean(), nullable=False, default=True)

    @classmethod

    def get_by_key(cls, section, key):

        """ Return specified Ui object, or None if not found. """

        return cls.query().filter_by(ui_section=section, ui_key=key).scalar()

    @classmethod

    def get_or_create(cls, section, key):

        """ Return specified Ui object, creating it if necessary. """

        setting = cls.get_by_key(section, key)

        if setting is None:

            setting = cls(ui_section=section, ui_key=key)

            meta.Session().add(setting)

        return setting

    @classmethod

    def get_builtin_hooks(cls):

        q = cls.query()

        q = q.filter(cls.ui_key.in_([cls.HOOK_UPDATE, cls.HOOK_REPO_SIZE]))

        q = q.filter(cls.ui_section == 'hooks')

        q = q.order_by(cls.ui_section, cls.ui_key)

        return q.all()

    @classmethod

    def get_custom_hooks(cls):

        q = cls.query()

        q = q.filter(~cls.ui_key.in_([cls.HOOK_UPDATE, cls.HOOK_REPO_SIZE]))

        q = q.filter(cls.ui_section == 'hooks')

        q = q.order_by(cls.ui_section, cls.ui_key)

        return q.all()

    @classmethod

    def get_repos_location(cls):

        return cls.get_by_key('paths', '/').ui_value

    @classmethod

    def create_or_update_hook(cls, key, val):

        new_ui = cls.get_or_create('hooks', key)

        new_ui.ui_active = True

        new_ui.ui_value = val

    def __repr__(self):

        chained_validators = [v.ValidForkName(edit, old_data)]

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

    return _RepoForkForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        title = v.UnicodeString(strip=True, not_empty=False)

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

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

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

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

    return _ApplicationSettingsForm

def ApplicationVisualisationForm():

    class _ApplicationVisualisationForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        show_public_icon = v.StringBoolean(if_missing=False)

        show_private_icon = v.StringBoolean(if_missing=False)

        stylify_metalabels = v.StringBoolean(if_missing=False)

        repository_fields = v.StringBoolean(if_missing=False)

        lightweight_journal = v.StringBoolean(if_missing=False)

        dashboard_items = v.Int(min=5, not_empty=True)

        admin_grid_items = v.Int(min=5, not_empty=True)

        show_version = v.StringBoolean(if_missing=False)

        use_gravatar = v.StringBoolean(if_missing=False)

        gravatar_url = v.UnicodeString(min=3)

        clone_uri_tmpl = v.UnicodeString(min=3)

        clone_ssh_tmpl = v.UnicodeString()

    return _ApplicationVisualisationForm

def ApplicationUiSettingsForm():

    class _ApplicationUiSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        paths_root_path = All(

            v.ValidPath(),

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

        )

        extensions_largefiles = v.StringBoolean(if_missing=False)

        extensions_hggit = v.StringBoolean(if_missing=False)

    return _ApplicationUiSettingsForm

def DefaultPermissionsForm(repo_perms_choices, group_perms_choices,

                           user_group_perms_choices, create_choices,

                           user_group_create_choices, fork_choices,

                           register_choices, extern_activate_choices):

    class _DefaultPermissionsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        overwrite_default_repo = v.StringBoolean(if_missing=False)

        overwrite_default_group = v.StringBoolean(if_missing=False)

        overwrite_default_user_group = v.StringBoolean(if_missing=False)

        anonymous = v.StringBoolean(if_missing=False)

        default_repo_perm = v.OneOf(repo_perms_choices)

        default_group_perm = v.OneOf(group_perms_choices)

        default_user_group_perm = v.OneOf(user_group_perms_choices)

        default_repo_create = v.OneOf(create_choices)

        default_user_group_create = v.OneOf(user_group_create_choices)

        default_fork = v.OneOf(fork_choices)

        default_register = v.OneOf(register_choices)

        default_extern_activate = v.OneOf(extern_activate_choices)

    return _DefaultPermissionsForm

def CustomDefaultPermissionsForm():

    class _CustomDefaultPermissionsForm(formencode.Schema):

        filter_extra_fields = True

        allow_extra_fields = True

        create_repo_perm = v.StringBoolean(if_missing=False)

        create_user_group_perm = v.StringBoolean(if_missing=False)

        #create_repo_group_perm Impl. later

        fork_repo_perm = v.StringBoolean(if_missing=False)

    return _CustomDefaultPermissionsForm

def DefaultsForm(edit=False, old_data=None, supported_backends=kallithea.BACKENDS):

    class _DefaultsForm(formencode.Schema):

        allow_extra_fields = True

${h.form(url('admin_settings'), method='post')}

    <div class="form">

            <div class="form-group">

                <label class="control-label">${_('Hooks')}:</label>

                <div>

                    <div class="checkbox">

                        <label>

                            ${_('Show repository size after push')}

                        </label>

                    </div>

                    <div class="checkbox">

                        <label>

                            ${_('Update repository after push (hg update)')}

                        </label>

                    </div>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label">${_('Mercurial extensions')}:</label>

                <div>

                    <div class="checkbox">

                        <label>

                            ${h.checkbox('extensions_largefiles','True')}

                            ${_('Enable largefiles extension')}

                        </label>

                    </div>

                    ##<div class="checkbox">

                    ##    <label>

                    ##        ${h.checkbox('extensions_hggit','True')}

                    ##        ${_('Enable hg-git extension')}

                    ##    </label>

                    ##</div>

                    ##<span class="help-block">${_('Requires hg-git library to be installed. Enables cloning of remote Git repositories while converting them to Mercurial.')}</span>

                </div>

            </div>

            %if c.visual.allow_repo_location_change:

            <div class="form-group">

                <label class="control-label" for="paths_root_path">${_('Location of repositories')}:</label>

                <div>

                    <div class="input-group">

                        ${h.text('paths_root_path',size=60,readonly="readonly",class_='form-control')}

                        <span id="path_unlock" data-toggle="tooltip" class="input-group-btn"

                            title="${_('Click to unlock. You must restart Kallithea in order to make this setting take effect.')}">

                            <button type="button" class="btn btn-default btn-sm"><i id="path_unlock_icon" class="icon-lock"></i></button>

                        </span>

                    </div>

                    <span class="help-block">${_('Filesystem location where repositories are stored. After changing this value, a restart and rescan of the repository folder are both required.')}</span>

                </div>

            </div>

            %else:

            ## form still requires this but we cannot internally change it anyway

            ${h.hidden('paths_root_path',size=30,readonly="readonly")}

            %endif

            <div class="form-group">

                <div class="buttons">

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

                    ${h.reset('reset',_('Reset'),class_="btn btn-default")}

                </div>

            </div>

    </div>

        response.mustcontain('test_hooks_1')

        response.mustcontain('cd %s' % base.TESTS_TMP_PATH)

        # test_edit_custom_hook

        response = self.app.post(base.url('admin_settings_hooks'),

                                params=dict(hook_ui_key='test_hooks_1',

                                            hook_ui_value='old_value_of_hook_1',

                                            hook_ui_value_new='new_value_of_hook_1',

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        response = response.follow()

        response.mustcontain('test_hooks_1')

        response.mustcontain('new_value_of_hook_1')

        # test_add_existing_custom_hook

        response = self.app.post(base.url('admin_settings_hooks'),

                                params=dict(new_hook_ui_key='test_hooks_1',

                                            new_hook_ui_value='attempted_new_value',

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        self.checkSessionFlash(response, 'Hook already exists')

        response = response.follow()

        response.mustcontain('test_hooks_1')

        response.mustcontain('new_value_of_hook_1')

    def test_create_custom_hook_delete(self):

        self.log_user()

        response = self.app.post(base.url('admin_settings_hooks'),

                                params=dict(new_hook_ui_key='test_hooks_2',

                                            new_hook_ui_value='cd %s2' % base.TESTS_TMP_PATH,

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        self.checkSessionFlash(response, 'Added new hook')

        response = response.follow()

        response.mustcontain('test_hooks_2')

        response.mustcontain('cd %s2' % base.TESTS_TMP_PATH)

        hook_id = db.Ui.get_by_key('hooks', 'test_hooks_2').ui_id

        ## delete

        self.app.post(base.url('admin_settings_hooks'),

                        params=dict(hook_id=hook_id, _session_csrf_secret_token=self.session_csrf_secret_token()))

        response = self.app.get(base.url('admin_settings_hooks'))

        response.mustcontain(no=['test_hooks_2'])

        response.mustcontain(no=['cd %s2' % base.TESTS_TMP_PATH])

    def test_add_existing_builtin_hook(self):

        self.log_user()

        response = self.app.post(base.url('admin_settings_hooks'),

                                            new_hook_ui_value='attempted_new_value',

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        self.checkSessionFlash(response, 'Builtin hooks are read-only')

        response = response.follow()

    def test_index_search(self):

        self.log_user()

        response = self.app.get(base.url('admin_settings_search'))

    def test_index_system(self):

        self.log_user()

        response = self.app.get(base.url('admin_settings_system'))

    def test_ga_code_active(self):

        self.log_user()

        old_title = 'Kallithea'

        old_realm = 'Kallithea authentication'

        new_ga_code = 'ga-test-123456789'

        response = self.app.post(base.url('admin_settings_global'),

                        params=dict(title=old_title,

                                 realm=old_realm,

                                 ga_code=new_ga_code,

                                 captcha_private_key='',

                                 captcha_public_key='',

                                 _session_csrf_secret_token=self.session_csrf_secret_token(),

                                 ))

        self.checkSessionFlash(response, 'Updated application settings')

        assert db.Setting.get_app_settings()['ga_code'] == new_ga_code

        response = response.follow()

        response.mustcontain("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code)

    def test_ga_code_inactive(self):

        self.log_user()

        old_title = 'Kallithea'

        old_realm = 'Kallithea authentication'

        new_ga_code = ''

        response = self.app.post(base.url('admin_settings_global'),

                        params=dict(title=old_title,

                                 realm=old_realm,

                                 ga_code=new_ga_code,

                                 captcha_private_key='',

                                 captcha_public_key='',

                                 _session_csrf_secret_token=self.session_csrf_secret_token(),

                                 ))

        self.checkSessionFlash(response, 'Updated application settings')

        assert db.Setting.get_app_settings()['ga_code'] == new_ga_code

        response = response.follow()