"""

kallithea.lib.base

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

The base Controller API

Provides the BaseController class for subclassing. And usage in different

controllers

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: Oct 06, 2010

:author: marcink

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

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

"""

import datetime

import decorator

import logging

import time

import traceback

import warnings

import webob.exc

import paste.httpexceptions

import paste.auth.basic

import paste.httpheaders

from webhelpers.pylonslib import secure_form

from tg import config, tmpl_context as c, request, response, session, render_template

from tg import TGController

from tg.i18n import ugettext as _

from kallithea import __version__, BACKENDS

from kallithea.config.routing import url

from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \

    safe_str, safe_int

from kallithea.lib import auth_modules

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.compat import json

from kallithea.lib.utils import get_repo_slug

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.vcs.exceptions import RepositoryError, EmptyRepositoryError, ChangesetDoesNotExistError

from kallithea.model import meta

from kallithea.model.db import PullRequest, Repository, Ui, User, Setting

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

def render(template_path):

    return render_template({'url': url}, 'mako', template_path)

def _filter_proxy(ip):

    """

    HEADERS can have multiple ips inside the left-most being the original

    client, and each successive proxy that passed the request adding the IP

    address where it received the request from.

    :param ip:

    """

    if ',' in ip:

        _ips = ip.split(',')

        _first_ip = _ips[0].strip()

        log.debug('Got multiple IPs %s, using %s', ','.join(_ips), _first_ip)

        return _first_ip

    return ip

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

    ip = environ.get(proxy_key)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(proxy_key2)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(def_key, '0.0.0.0')

    return _filter_proxy(ip)

def _get_access_path(environ):

    path = environ.get('PATH_INFO')

    org_req = environ.get('tg.original_request')

    if org_req:

        path = org_req.environ.get('PATH_INFO')

    return path

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

        """

        _before is called before controller methods and after __call__

        """

        c.kallithea_version = __version__

        rc_config = Setting.get_app_settings()

        # Visual options

        c.visual = AttributeDict({})

        ## DB stored

        c.visual.show_public_icon = str2bool(rc_config.get('show_public_icon'))

        c.visual.show_private_icon = str2bool(rc_config.get('show_private_icon'))

        c.visual.stylify_metalabels = str2bool(rc_config.get('stylify_metalabels'))

        c.visual.page_size = safe_int(rc_config.get('dashboard_items', 100))

        c.visual.admin_grid_items = safe_int(rc_config.get('admin_grid_items', 100))

        c.visual.repository_fields = str2bool(rc_config.get('repository_fields'))

        c.visual.show_version = str2bool(rc_config.get('show_version'))

        c.visual.use_gravatar = str2bool(rc_config.get('use_gravatar'))

        c.visual.gravatar_url = rc_config.get('gravatar_url')

        c.ga_code = rc_config.get('ga_code')

        # TODO: replace undocumented backwards compatibility hack with db upgrade and rename ga_code

        if c.ga_code and '<' not in c.ga_code:

            c.ga_code = '''<script type="text/javascript">

                var _gaq = _gaq || [];

                _gaq.push(['_setAccount', '%s']);

                _gaq.push(['_trackPageview']);

                (function() {

                    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;

                    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

                    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);

                    })();

            </script>''' % c.ga_code

        c.site_name = rc_config.get('title')

        c.clone_uri_tmpl = rc_config.get('clone_uri_tmpl')

        ## INI stored

        c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))

        c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))

        c.instance_id = config.get('instance_id')

        c.issues_url = config.get('bugtracker', url('issues_url'))

        # END CONFIG VARS

        c.repo_name = get_repo_slug(request)  # can be empty

        c.backends = BACKENDS.keys()

        self.cut_off_limit = safe_int(config.get('cut_off_limit'))

        c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()

        self.scm_model = ScmModel()

    @staticmethod

    def _determine_auth_user(api_key, bearer_token, session_authuser):

        """

        Create an `AuthUser` object given the API key/bearer token

        (if any) and the value of the authuser session cookie.

        """

        # Authenticate by bearer token

        if bearer_token is not None:

            api_key = bearer_token

        # Authenticate by API key

        if api_key is not None:

            au = AuthUser(dbuser=User.get_by_api_key(api_key),

                authenticating_api_key=api_key, is_external_auth=True)

            if au.is_anonymous:

                log.warning('API key ****%s is NOT valid', api_key[-4:])

                raise webob.exc.HTTPForbidden(_('Invalid API key'))

            return au

        # Authenticate by session cookie

        # In ancient login sessions, 'authuser' may not be a dict.

        # In that case, the user will have to log in again.

        # v0.3 and earlier included an 'is_authenticated' key; if present,

        # this must be True.

        if isinstance(session_authuser, dict) and session_authuser.get('is_authenticated', True):

            try:

                return AuthUser.from_cookie(session_authuser)

            except UserCreationError as e:

                # container auth or other auth functions that create users on

                # the fly can throw UserCreationError to signal issues with

                # user creation. Explanation should be provided in the

                # exception object.

                from kallithea.lib import helpers as h

                h.flash(e, 'error', logf=log.error)

        # Authenticate by auth_container plugin (if enabled)

        if any(

            plugin.is_container_auth

            for plugin in auth_modules.get_auth_plugins()

        ):

      <li class="${'active' if current == 'gists' else ''} dropdown">

        <a class="menu_link dropdown-toggle" data-toggle="dropdown" role="button" title="${_('Show public gists')}"  href="${h.url('gists')}">

          <i class="icon-clippy"></i>${_('Gists')} <span class="caret"></span>

        </a>

          <ul class="dropdown-menu" role="menu">

            <li><a href="${h.url('new_gist', public=1)}"><i class="icon-paste"></i>${_('Create New Gist')}</a></li>

            <li><a href="${h.url('gists')}"><i class="icon-globe"></i>${_('All Public Gists')}</a></li>

            %if request.authuser.username != 'default':

              <li><a href="${h.url('gists', public=1)}"><i class="icon-user"></i>${_('My Public Gists')}</a></li>

              <li><a href="${h.url('gists', private=1)}"><i class="icon-lock"></i>${_('My Private Gists')}</a></li>

            %endif

          </ul>

      </li>

    <li class="${'active' if current == 'search' else ''}">

        <a class="menu_link" title="${_('Search in repositories')}"  href="${h.url('search')}">

          <i class="icon-search"></i>${_('Search')}

        </a>

    </li>

    % if h.HasPermissionAny('hg.admin')('access admin main page'):

      <li class="${'active' if current == 'admin' else ''} dropdown">

        <a class="menu_link dropdown-toggle" data-toggle="dropdown" role="button" title="${_('Admin')}" href="${h.url('admin_home')}">

          <i class="icon-gear"></i>${_('Admin')} <span class="caret"></span>

        </a>

        ${admin_menu()}

      </li>

    % elif request.authuser.repositories_admin or request.authuser.repository_groups_admin or request.authuser.user_groups_admin:

    <li class="${'active' if current == 'admin' else ''} dropdown">

        <a class="menu_link dropdown-toggle" data-toggle="dropdown" role="button" title="${_('Admin')}" href="">

          <i class="icon-gear"></i>${_('Admin')}

        </a>

        ${admin_menu_simple(request.authuser.repositories_admin,

                            request.authuser.repository_groups_admin,

                            request.authuser.user_groups_admin or h.HasPermissionAny('hg.usergroup.create.true')())}

    </li>

    % endif

    <li class="${'active' if current == 'my_pullrequests' else ''}">

      <a class="menu_link" title="${_('My Pull Requests')}" href="${h.url('my_pullrequests')}">

        <i class="icon-git-pull-request"></i>${_('My Pull Requests')}

        %if c.my_pr_count != 0:

          <span class="badge">${c.my_pr_count}</span>

        %endif

      </a>

    </li>

    ## USER MENU

    <li class="dropdown">

      <a class="menu_link dropdown-toggle" data-toggle="dropdown" role="button" id="quick_login_link"

          ${h.gravatar_div(request.authuser.email, size=20, div_class="icon")}

          %if request.authuser.username != 'default':

            <span class="menu_link_user">${request.authuser.username}</span>

          %else:

              <span>${_('Not Logged In')}</span>

          %endif

          <i class="caret"></i>

      </a>

      <div class="dropdown-menu user-menu" role="menu">

        <div id="quick_login" role="form" aria-describedby="quick_login_h" aria-hidden="true" class="container-fluid">

          %if request.authuser.username == 'default' or request.authuser.user_id is None:

            ${h.form(h.url('login_home', came_from=request.path_qs), class_='form clearfix')}

                <h4 id="quick_login_h">${_('Login to Your Account')}</h4>

                <label>

                    ${_('Username')}:

                    ${h.text('username',class_='form-control')}

                </label>

                <label>

                    ${_('Password')}:

                    ${h.password('password',class_='form-control')}

                </label>

                <div class="password_forgotten">

                    ${h.link_to(_('Forgot password?'),h.url('reset_password'))}

                </div>

                <div class="register">

                    %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():

                        ${h.link_to(_("Don't have an account?"),h.url('register'))}

                    %endif

                </div>

                <div class="submit">

                    ${h.submit('sign_in',_('Log In'),class_="btn btn-default btn-xs")}

                </div>

            ${h.end_form()}

          %else:

            <div class="pull-left">

                ${h.gravatar_div(request.authuser.email, size=48, div_class="big_gravatar")}

                <b class="full_name">${request.authuser.full_name_or_username}</b>

                <div class="email">${request.authuser.email}</div>

            </div>

            <div id="quick_login_h" class="pull-right list-group text-right">

              ${h.link_to(_('My Account'),h.url('my_account'),class_='list-group-item')}

              %if not request.authuser.is_external_auth:

                ## Cannot log out if using external (container) authentication.

                ${h.link_to(_('Log Out'), h.url('logout_home'),class_='list-group-item')}

              %endif

            </div>

          %endif

        </div>

      </div>

    </li>

  </ul>

    <script type="text/javascript">

        $(document).ready(function(){

            var visual_show_public_icon = ${h.js(c.visual.show_public_icon)};

            var cache = {}

            /*format the look of items in the list*/

            var format = function(state){

                if (!state.id){

                  return state.text; // optgroup

                }

                var obj_dict = state.obj;

                var tmpl = '';

                if(obj_dict && state.type == 'repo'){

                    tmpl += '<span class="repo-icons">';

                    if(obj_dict['repo_type'] === 'hg'){

                        tmpl += '<span class="label label-repo" title="${_('Mercurial repository')}">hg</span> ';

                    }

                    else if(obj_dict['repo_type'] === 'git'){

                        tmpl += '<span class="label label-repo" title="${_('Git repository')}">git</span> ';

                    }

                    if(obj_dict['private']){

                        tmpl += '<i class="icon-lock"></i>';

                    }

                    else if(visual_show_public_icon){

                        tmpl += '<i class="icon-globe"></i>';

                    }

                    tmpl += '</span>';

                }

                if(obj_dict && state.type == 'group'){

                        tmpl += '<i class="icon-folder"></i>';

                }

                tmpl += state.text;

                return tmpl;

            }

            $("#repo_switcher").select2({