# -*- 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.users

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

Users crud controller

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 4, 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 sqlalchemy.sql.expression import func

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPNotFound

import kallithea

import kallithea.lib.helpers as h

from kallithea.controllers import base

from kallithea.lib import auth_modules, webutils

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.exceptions import DefaultUserException, UserCreationError, UserOwnsReposException

from kallithea.model import db, meta, userlog

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.forms import CustomDefaultPermissionsForm, UserForm

from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class UsersController(base.BaseController):

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

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

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

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

        c.users_list = db.User.query().order_by(db.User.username) \

                        .filter_by(is_default_user=False) \

                        .order_by(func.lower(db.User.username)) \

                        .all()

        users_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        grav_tmpl = '<div class="gravatar">%s</div>'

        def username(user_id, username):

            return template.get_def("user_name") \

                .render_unicode(user_id, username, _=_, h=h, c=c)

        def user_actions(user_id, username):

            return template.get_def("user_actions") \

                .render_unicode(user_id, username, _=_, h=h, c=c)

        for user in c.users_list:

            users_data.append({

                "gravatar": grav_tmpl % h.gravatar(user.email, size=20),

                "raw_name": user.username,

                "username": username(user.user_id, user.username),

                "firstname": webutils.escape(user.name),

                "lastname": webutils.escape(user.lastname),

                "last_login": fmt_date(user.last_login),

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

# -*- 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.feed

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

Feed 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 23, 2010

:author: marcink

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

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

"""

import logging

from beaker.cache import cache_region

from tg import response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

import kallithea

import kallithea.lib.helpers as h

from kallithea.controllers import base

from kallithea.lib import feeds, webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.diffs import DiffProcessor

log = logging.getLogger(__name__)

class FeedController(base.BaseRepoController):

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

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

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

    def _get_title(self, cs):

    def __get_desc(self, cs):

        desc_msg = [(_('%s committed on %s')

        # branches, tags, bookmarks

        for branch in cs.branches:

            desc_msg.append('branch: %s<br/>' % branch)

        for book in cs.bookmarks:

            desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        changes = []

        diff_limit = safe_int(kallithea.CONFIG.get('rss_cut_off_limit', 32 * 1024))

        raw_diff = cs.diff()

        diff_processor = DiffProcessor(raw_diff,

                                       diff_limit=diff_limit,

                                       inline_diff=False)

        for st in diff_processor.parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if diff_processor.limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        # rev link

        _url = webutils.canonical_url('changeset_home', repo_name=c.db_repo.repo_name,

                   revision=cs.raw_id)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(webutils.urlify_text(cs.message))

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if asbool(kallithea.CONFIG.get('rss_include_diff', False)):

            desc_msg.append('\n\n')

            desc_msg.append(safe_str(raw_diff))

        desc_msg.append('</pre>')

        return desc_msg

    def _feed(self, repo_name, feeder):

        """Produce a simple feed"""

        @cache_region('long_term_file', '_get_feed_from_cache')

        def _get_feed_from_cache(*_cache_keys):  # parameters are not really used - only as caching key

            header = dict(

                title=_('%s %s feed') % (c.site_name, repo_name),

                link=webutils.canonical_url('summary_home', repo_name=repo_name),

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

"""

Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import hashlib

import logging

import re

import textwrap

import urllib.parse

from beaker.cache import cache_region

from pygments import highlight as code_highlight

from pygments.formatters.html import HtmlFormatter

from tg import tmpl_context as c

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.annotate import annotate_highlight

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel

from kallithea.lib.diffs import BIN_FILENODE, CHMOD_FILENODE, DEL_FILENODE, MOD_FILENODE, NEW_FILENODE, RENAMED_FILENODE

from kallithea.lib.pygmentsutils import get_custom_lexer

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model import db

from kallithea.model.changeset_status import ChangesetStatusModel

# mute pyflakes "imported but unused"

# from webutils

assert Option

assert canonical_url

assert checkbox

assert chop_at

assert end_form

assert form

assert format_byte_size

assert hidden

assert js

assert jshtml

assert password

assert pop_flash_messages

assert radio

assert render_w_mentions

assert reset

assert safeid

assert select

assert session_csrf_secret_name

assert session_csrf_secret_token

assert submit

assert text

assert textarea

assert urlify_text

assert wrap_paragraphs

# from kallithea.lib.auth

assert HasPermissionAny

assert HasRepoGroupPermissionLevel

assert HasRepoPermissionLevel

# from utils2

assert credentials_filter

assert link_to_ref

assert time_to_datetime

# from vcs

assert EmptyChangeset

log = logging.getLogger(__name__)

def FID(raw_id, path):

    """

    Creates a unique ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    """

    return 'C-%s-%s' % (short_id(raw_id), hashlib.md5(safe_bytes(path)).hexdigest()[:12])

def get_ignore_whitespace_diff(GET):

    """Return true if URL requested whitespace to be ignored"""

    return bool(GET.get('ignorews'))

def ignore_whitespace_link(GET, anchor=None):

    """Return snippet with link to current URL with whitespace ignoring toggled"""

    params = dict(GET)  # ignoring duplicates

    if get_ignore_whitespace_diff(GET):

        params.pop('ignorews')

        title = _("Show whitespace changes")

    else:

        params['ignorews'] = '1'

        title = _("Ignore whitespace changes")

    params['anchor'] = anchor

    return link_to(

        literal('<i class="icon-strike"></i>'),

        url.current(**params),

        title=title,

        **{'data-toggle': 'tooltip'})

def get_diff_context_size(GET):

    """Return effective context size requested in URL"""

    return safe_int(GET.get('context'), default=3)

def increase_context_link(GET, anchor=None):

    """Return snippet with link to current URL with double context size"""

    context = get_diff_context_size(GET) * 2

    params = dict(GET)  # ignoring duplicates

    params['context'] = str(context)

# -*- 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.utils2

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

Some simple helper functions.

Note: all these functions should be independent of Kallithea classes, i.e.

models, controllers, etc.  to prevent import cycles.

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: Jan 5, 2011

:author: marcink

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

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

"""

import binascii

import datetime

import hashlib

import json

import logging

import os

import re

import string

import sys

import time

import urllib.parse

from distutils.version import StrictVersion

import bcrypt

import urlobject

from sqlalchemy.engine import url as sa_url

from sqlalchemy.exc import ArgumentError

from tg import tmpl_context

from tg.support.converters import asbool, aslist

from webhelpers2.text import collapse, remove_formatting, strip_tags

import kallithea

from kallithea.lib import webutils

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

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, safe_bytes, safe_str  # re-export

from kallithea.lib.vcs.utils.lazy import LazyProperty

try:

    import pwd

except ImportError:

    pass

log = logging.getLogger(__name__)

# mute pyflakes "imported but unused"

assert asbool

assert aslist

assert ascii_bytes

assert ascii_str

assert safe_bytes

assert safe_str

assert LazyProperty

# get current umask value without changing it

umask = os.umask(0)

os.umask(umask)

def convert_line_endings(line, mode):

    """

    Converts a given line  "line end" according to given mode

    Available modes are::

        0 - Unix

        1 - Mac

        2 - DOS

    :param line: given line to convert

    :param mode: mode to convert to

        return 0

    elif line.endswith('\r'):

        return 1

    else:

        return default

def generate_api_key():

    """

    Generates a random (presumably unique) API key.

    This value is used in URLs and "Bearer" HTTP Authorization headers,

    which in practice means it should only contain URL-safe characters

    (RFC 3986):

        unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"

    """

    # Hexadecimal certainly qualifies as URL-safe.

    return ascii_str(binascii.hexlify(os.urandom(20)))

def safe_int(val, default=None):

    """

    Returns int() of val if val is not convertable to int use default

    instead

    :param val:

    :param default:

    """

    try:

        val = int(val)

    except (ValueError, TypeError):

        val = default

    return val

def remove_suffix(s, suffix):

    if s.endswith(suffix):

        s = s[:-1 * len(suffix)]

    return s

def remove_prefix(s, prefix):

    if s.startswith(prefix):

        s = s[len(prefix):]

    return s

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :rtype: str

    :returns: filtered list of strings

    """

    if not uri:

        return []

    proto = ''

    for pat in ('https://', 'http://', 'git://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return [_f for _f in [proto, host, port] if _f]

def credentials_filter(uri):

    """

    Returns a url with removed credentials

    :param uri:

    """

    uri = uri_filter(uri)

    # check if we have port

    if len(uri) > 2 and uri[2]:

        uri[2] = ':' + uri[2]

    return ''.join(uri)

def get_clone_url(clone_uri_tmpl, prefix_url, repo_name, repo_id, username=None):

# -*- 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.webutils

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

Helper functions that may rely on the current WSGI request, exposed in the TG2

thread-local "global" variables. It should have few dependencies so it can be

imported anywhere - just like the global variables can be used everywhere.

"""

import json

import logging

import random

import re

from tg import request, session

from webhelpers2.html import HTML, escape, literal

from webhelpers2.html.tags import NotGiven, Option, Options, _input

from webhelpers2.html.tags import _make_safe_id_component as safeid

from webhelpers2.html.tags import checkbox, end_form

from webhelpers2.html.tags import form as insecure_form

from webhelpers2.html.tags import hidden, link_to, password, radio

from webhelpers2.html.tags import select as webhelpers2_select

from webhelpers2.html.tags import submit, text, textarea

from webhelpers2.number import format_byte_size

from webhelpers2.text import chop_at, truncate, wrap_paragraphs

import kallithea

log = logging.getLogger(__name__)

# mute pyflakes "imported but unused"

assert Option

assert checkbox

assert chop_at

assert end_form

assert escape

assert format_byte_size

assert link_to

assert literal

assert password

assert radio

assert safeid

assert submit

assert text

assert textarea

assert truncate

assert wrap_paragraphs

#

# General Kallithea URL handling

#

class UrlGenerator(object):

    """Emulate pylons.url in providing a wrapper around routes.url

    This code was added during migration from Pylons to Turbogears2. Pylons

    already provided a wrapper like this, but Turbogears2 does not.

    When the routing of Kallithea is changed to use less Routes and more

    Turbogears2-style routing, this class may disappear or change.

                continue

            log.debug('issue pattern %r: %r -> %r %r', k, issue_pat, issue_server_link, issue_sub)

            def issues_replace(match_obj,

                               issue_server_link=issue_server_link, issue_sub=issue_sub):

                try:

                    issue_url = match_obj.expand(issue_server_link)

                except (IndexError, re.error) as e:

                    log.error('invalid issue_url setting %r -> %r %r. Error: %s', issue_pat, issue_server_link, issue_sub, str(e))

                    issue_url = issue_server_link

                issue_url = issue_url.replace('{repo}', repo_name)

                issue_url = issue_url.replace('{repo_name}', repo_name.split(kallithea.URL_SEP)[-1])

                # if issue_sub is empty use the matched issue reference verbatim

                if not issue_sub:

                    issue_text = match_obj.group()

                else:

                    try:

                        issue_text = match_obj.expand(issue_sub)

                    except (IndexError, re.error) as e:

                        log.error('invalid issue_sub setting %r -> %r %r. Error: %s', issue_pat, issue_server_link, issue_sub, str(e))

                        issue_text = match_obj.group()

                return (

                    '<a class="issue-tracker-link" href="%(url)s">'

                    '%(text)s'

                    '</a>'

                    ) % {

                     'url': issue_url,

                     'text': issue_text,

                    }

            def tmp_urlify_issues_f(s, issue_re=issue_re, issues_replace=issues_replace, chain_f=tmp_urlify_issues_f):

                return issue_re.sub(issues_replace, chain_f(s))

        # Set tmp function globally - atomically

        _urlify_issues_f = tmp_urlify_issues_f

    return _urlify_issues_f(newtext)

def render_w_mentions(source, repo_name=None):

    """

    Render plain text with revision hashes and issue references urlified

    and with @mention highlighting.

    """

    s = urlify_text(source, repo_name=repo_name)

    return literal('<div class="formatted-fixed">%s</div>' % s)