# -*- 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.bin.base

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

Base utils for shell scripts

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: May 09, 2013

:author: marcink

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

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

"""

import os

import sys

import random

import urllib2

import pprint

CONFIG_NAME = '.config/kallithea'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

def api_call(apikey, apihost, method=None, **kw):

    """

    Api_call wrapper for Kallithea.

    :param apikey:

    :param apihost:

    :param format: formatting, pretty means prints and pprint of json

     json returns unparsed json

    :param method:

    :returns: json response from server

    """

    def _build_data(random_id):

        """

        Builds API data with given random ID

        :param random_id:

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    apihost = apihost.rstrip('/')

    id_ = random.randrange(1, 9999)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      data=json.dumps(_build_data(id_)),

                      headers={'content-type': 'text/plain'})

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    json_data = json.loads(raw_json)

    id_ret = json_data['id']

    if id_ret == id_:

        return json_data

    else:

        _formatted_json = pprint.pformat(json_data)

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

class RcConf(object):

    """

    Kallithea config for API

    conf = RcConf()

    conf['key']

    """

    def __init__(self, config_location=None, autoload=True, autocreate=False,

                 config=None):

        HOME = os.getenv('HOME', os.getenv('USERPROFILE')) or ''

        HOME_CONF = os.path.abspath(os.path.join(HOME, CONFIG_NAME))

        self._conf_name = HOME_CONF if not config_location else config_location

        self._conf = {}

        if autocreate:

            self.make_config(config)

        if autoload:

            self._conf = self.load_config()

    def __getitem__(self, key):

        return self._conf[key]

    def __nonzero__(self):

        if self._conf:

            return True

        return False

    def __eq__(self):

        return self._conf.__eq__()

    def __repr__(self):

        return 'RcConf<%s>' % self._conf.__repr__()

    def make_config(self, config):

        """

        Saves given config as a JSON dump in the _conf_name location

        :param config:

        """

        update = False

        if os.path.exists(self._conf_name):

            update = True

        with open(self._conf_name, 'wb') as f:

            json.dump(config, f, indent=4)

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

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

Api CLI client 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: Jun 3, 2012

:author: marcink

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

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

"""

from __future__ import with_statement

import sys

import argparse

from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

def argparser(argv):

    usage = (

      "kallithea-api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] "

      "METHOD <key:val> <key2:val> ...\n"

      "Create config file: kallithea-api --apikey=<key> --apihost=http://your.kallithea.server --save-config"

    )

    parser = argparse.ArgumentParser(description='Kallithea API cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group.add_argument('--config', help='config file')

    group.add_argument('--save-config', action='store_true', help='save the given config into a file')

    group = parser.add_argument_group('API')

    group.add_argument('method', metavar='METHOD', nargs='?', type=str, default=None,

            help='API method name to call followed by key:value attributes',

    )

    group.add_argument('--format', dest='format', type=str,

            help='output format default: `%s` can '

                 'be also `%s`' % (FORMAT_PRETTY, FORMAT_JSON),

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.save_config:

        if not api_credentials_given:

            raise parser.error('--save-config requires --apikey and --apihost')

        conf = RcConf(config_location=args.config,

                      autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.exit()

    if not conf:

        conf = RcConf(config_location=args.config, autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    apihost = args.apihost or conf['apihost']

    method = args.method

    # if we don't have method here it's an error

    if not method:

        parser.error('Please specify method name')

    try:

        margs = dict(map(lambda s: s.split(':', 1), other))

        sys.stderr.write('Error parsing arguments \n')

        sys.exit()

    if args.format == FORMAT_PRETTY:

        print 'Calling method %s => %s' % (method, apihost)

    json_resp = api_call(apikey, apihost, method, **margs)

    error_prefix = ''

    if json_resp['error']:

        error_prefix = 'ERROR:'

        json_data = json_resp['error']

    else:

        json_data = json_resp['result']

    if args.format == FORMAT_JSON:

        print json.dumps(json_data)

    elif args.format == FORMAT_PRETTY:

        print 'Server response \n%s%s' % (

            error_prefix, json.dumps(json_data, indent=4, sort_keys=True)

        )

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

    group.add_argument('--show-defaults', help='Show all default variables for '

                                               'builtin template', action='store_true')

    args, other = parser.parse_known_args()

    return parser, args, other

def _escape_split(text, sep):

    """

    Allows for escaping of the separator: e.g. arg='foo\, bar'

    It should be noted that the way bash et. al. do command line parsing, those

    single quotes are required. a shameless ripoff from fabric project.

    """

    escaped_sep = r'\%s' % sep

    if escaped_sep not in text:

        return text.split(sep)

    before, _, after = text.partition(escaped_sep)

    startlist = before.split(sep)  # a regular split is fine here

    unfinished = startlist[-1]

    startlist = startlist[:-1]

    # recurse because there may be more escaped separators

    endlist = _escape_split(after, sep)

    # finish building the escaped value. we use endlist[0] becaue the first

    # part of the string sent in recursion is the rest of the escaped value.

    unfinished += sep + endlist[0]

    return startlist + [unfinished] + endlist[1:]  # put together all the parts

def _run(argv):

    parser, args, other = argparser(argv)

    if not len(sys.argv) > 1:

        print parser.print_help()

        sys.exit(0)

    # defaults that can be overwritten by arguments

    tmpl_stored_args = {

        'http_server': 'waitress',

        'lang': 'en',

        'database_engine': 'sqlite',

        'host': '127.0.0.1',

        'port': 5000,

        'error_aggregation_service': None,

    }

    if other:

        # parse arguments, we assume only first is correct

        kwargs = {}

        for el in _escape_split(other[0], ','):

            kv = _escape_split(el, '=')

            if len(kv) == 2:

                k, v = kv

                kwargs[k] = v

        # update our template stored args

        tmpl_stored_args.update(kwargs)

    # use default that cannot be replaced

    tmpl_stored_args.update({

        'uuid': lambda: uuid.uuid4().hex,

        'here': os.path.abspath(os.curdir),

    })

    if args.show_defaults:

        for k,v in tmpl_stored_args.iteritems():

            print '%s=%s' % (k, v)

        sys.exit(0)

    try:

        # built in template

        tmpl_file = os.path.join(here, TMPL)

        if args.template:

            tmpl_file = args.template

        with open(tmpl_file, 'rb') as f:

            tmpl_data = f.read()

            if args.raw:

                tmpl = tmpl_data

            else:

                tmpl = Template(tmpl_data).render(**tmpl_stored_args)

        with open(args.filename, 'wb') as f:

            f.write(tmpl)

        print 'Wrote new config file in %s' % (os.path.abspath(args.filename))

    except Exception:

        from mako import exceptions

        print exceptions.text_error_template().render()

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

if __name__ == '__main__':

    sys.exit(main(sys.argv))

# -*- 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.bin.__init__

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

LDAP sync script

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: Mar 06, 2013

:author: marcink

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

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

"""

import ldap

import urllib2

import uuid

from ConfigParser import ConfigParser

config = ConfigParser()

config.read('ldap_sync.conf')

class InvalidResponseIDError(Exception):

    """ Request and response don't have the same UUID. """

class ResponseError(Exception):

    """ Response has an error, something went wrong with request execution. """

class UserAlreadyInGroupError(Exception):

    """ User is already a member of the target group. """

class UserNotInGroupError(Exception):

    """ User is not a member of the target group. """

class API(object):

    def __init__(self, url, key):

        self.url = url

        self.key = key

    def get_api_data(self, uid, method, args):

        """Prepare dict for API post."""

        return {

            "id": uid,

            "api_key": self.key,

            "method": method,

            "args": args

        }

    def post(self, method, args):

        """Send a generic API post to Kallithea.

        This will generate the UUID for validation check after the

        response is returned. Handle errors and get the result back.

        """

        uid = str(uuid.uuid1())

        data = self.get_api_data(uid, method, args)

        data = json.dumps(data)

        headers = {'content-type': 'text/plain'}

        req = urllib2.Request(self.url, data, headers)

        response = urllib2.urlopen(req)

        response = json.load(response)

        if uid != response["id"]:

            raise InvalidResponseIDError("UUID does not match.")

        if response["error"] is not None:

            raise ResponseError(response["error"])

        return response["result"]

    def create_group(self, name, active=True):

        """Create the Kallithea user group."""

        args = {

            "group_name": name,

            "active": str(active)

        }

        self.post("create_user_group", args)

    def add_membership(self, group, username):

        """Add specific user to a group."""

        args = {

            "usersgroupid": group,

            "userid": username

        }

        result = self.post("add_user_to_user_group", args)

        if not result["success"]:

            raise UserAlreadyInGroupError("User %s already in group %s." %

                                          (username, group))

    def remove_membership(self, group, username):

        """Remove specific user from a group."""

        args = {

            "usersgroupid": group,

            "userid": username

        }

        result = self.post("remove_user_from_user_group", args)

        if not result["success"]:

            raise UserNotInGroupError("User %s not in group %s." %

                                      (username, group))

    def get_group_members(self, name):

        """Get the list of member usernames from a user group."""

        args = {"usersgroupid": name}

        members = self.post("get_user_group", args)['members']

from kallithea.model.db import UserLog

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import safe_int, remove_prefix, remove_suffix

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.helpers import Page

log = logging.getLogger(__name__)

def _journal_filter(user_log, search_term):

    """

    Filters sqlalchemy user_log based on search_term with whoosh Query language

    http://packages.python.org/Whoosh/querylang.html

    :param user_log:

    :param search_term:

    """

    log.debug('Initial search term: %r' % search_term)

    qry = None

    if search_term:

        qp = QueryParser('repository', schema=JOURNAL_SCHEMA)

        qp.add_plugin(DateParserPlugin())

        qry = qp.parse(unicode(search_term))

        log.debug('Filtering using parsed query %r' % qry)

    def wildcard_handler(col, wc_term):

        if wc_term.startswith('*') and not wc_term.endswith('*'):

            #postfix == endswith

            wc_term = remove_prefix(wc_term, prefix='*')

            return func.lower(col).endswith(wc_term)

        elif wc_term.startswith('*') and wc_term.endswith('*'):

            #wildcard == ilike

            wc_term = remove_prefix(wc_term, prefix='*')

            wc_term = remove_suffix(wc_term, suffix='*')

            return func.lower(col).contains(wc_term)

    def get_filterion(field, val, term):

        if field == 'repository':

            field = getattr(UserLog, 'repository_name')

        elif field == 'ip':

            field = getattr(UserLog, 'user_ip')

        elif field == 'date':

            field = getattr(UserLog, 'action_date')

        elif field == 'username':

            field = getattr(UserLog, 'username')

        else:

            field = getattr(UserLog, field)

        log.debug('filter field: %s val=>%s' % (field, val))

        #sql filtering

        if isinstance(term, query.Wildcard):

            return wildcard_handler(field, val)

        elif isinstance(term, query.Prefix):

            return func.lower(field).startswith(func.lower(val))

        elif isinstance(term, query.DateRange):

            return and_(field >= val[0], field <= val[1])

        return func.lower(field) == func.lower(val)

    if isinstance(qry, (query.And, query.Term, query.Prefix, query.Wildcard,

                        query.DateRange)):

        if not isinstance(qry, query.And):

            qry = [qry]

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

            user_log = user_log.filter(get_filterion(field, val, term))

    elif isinstance(qry, query.Or):

        filters = []

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

            filters.append(get_filterion(field, val, term))

        user_log = user_log.filter(or_(*filters))

    return user_log

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

        users_log = UserLog.query()\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))

        #FILTERING

        c.search_term = request.GET.get('filter')

        users_log = users_log.order_by(UserLog.action_date.desc())

        p = safe_int(request.GET.get('page', 1), 1)

        def url_generator(**kw):

            return url.current(filter=c.search_term, **kw)

        c.users_log = Page(users_log, page=p, items_per_page=10, url=url_generator)

        c.log_data = render('admin/admin_log.html')

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.log_data

        return render('admin/admin.html')

from kallithea.lib.utils2 import safe_int

from sqlalchemy.sql.expression import func

log = logging.getLogger(__name__)

class RepoGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired()

    def __before__(self):

        super(RepoGroupsController, self).__before__()

    def __load_defaults(self, allow_empty_group=False, exclude_group_ids=[]):

        if HasPermissionAll('hg.admin')('group edit'):

            #we're global admin, we're ok and we can create TOP level groups

            allow_empty_group = True

        #override the choices for this form, we need to filter choices

        #and display only those we have ADMIN right

        groups_with_admin_rights = RepoGroupList(RepoGroup.query().all(),

                                                 perm_set=['group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=groups_with_admin_rights,

                                                 show_empty_group=allow_empty_group)

        # exclude filtered ids

        c.repo_groups = filter(lambda x: x[0] not in exclude_group_ids,

                               c.repo_groups)

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        repo_group = RepoGroup.get_or_404(group_id)

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        # fill repository group users

        for p in repo_group.repo_group_to_perm:

            data.update({'u_perm_%s' % p.user.username:

                             p.permission.permission_name})

        # fill repository group groups

        for p in repo_group.users_group_to_perm:

            data.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

        return data

    def _revoke_perms_on_yourself(self, form_result):

        _up = filter(lambda u: c.authuser.username == u[0],

                     form_result['perms_updates'])

        _new = filter(lambda u: c.authuser.username == u[0],

                      form_result['perms_new'])

        if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':

            return True

        return False

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

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

        # url('repos_groups')

        _list = RepoGroup.query()\

                    .order_by(func.lower(RepoGroup.group_name))\

                    .all()

        group_iter = RepoGroupList(_list, perm_set=['group.admin'])

        repo_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

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

        repo_group_name = lambda repo_group_name, children_groups: (

            template.get_def("repo_group_name")

            .render(repo_group_name, children_groups, _=_, h=h, c=c)

        )

        repo_group_actions = lambda repo_group_id, repo_group_name, gr_count: (

            template.get_def("repo_group_actions")

            .render(repo_group_id, repo_group_name, gr_count, _=_, h=h, c=c,

                    ungettext=ungettext)

        )

        for repo_gr in group_iter:

            children_groups = map(h.safe_unicode,

                itertools.chain((g.name for g in repo_gr.parents),

                                (x.name for x in [repo_gr])))

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": repo_gr.group_description,

                "repos": repo_count,

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": repo_groups_data

        })

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

    def create(self):

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

        # url('repos_groups')

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        repo_group_form = RepoGroupForm(available_groups=

                                map(lambda k: unicode(k[0]), c.repo_groups))()

        try:

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

            RepoGroupModel().create(

                group_name=form_result['group_name'],

                group_description=form_result['group_description'],

                parent=form_result['group_parent_id'],

                owner=self.authuser.user_id,

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

            h.flash(_('Created repository group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of repository group %s') \

                    % request.POST.get('group_name'), category='error')

        parent_group_id = form_result['group_parent_id']

        #TODO: maybe we should get back to the main view, not the admin one

        return redirect(url('repos_groups', parent_group=parent_group_id))

    def new(self):

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

        # url('new_repos_group')

        if HasPermissionAll('hg.admin')('group create'):

            #we're global admin, we're ok and we can create TOP level groups

            pass

        else:

            # we pass in parent group into creation form, thus we know

            # what would be the group, we can check perms here !

            group_id = safe_int(request.GET.get('parent_group'))

            group = RepoGroup.get(group_id) if group_id else None

            group_name = group.group_name if group else None

            if HasRepoGroupPermissionAll('group.admin')(group_name, 'group create'):

                pass

            else:

                return abort(403)

        self.__load_defaults()

        return render('admin/repo_groups/repo_group_add.html')

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def update(self, group_name):

        """PUT /repo_groups/group_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repos_group', group_name=GROUP_NAME),

        #           method='put')

        # url('repos_group', group_name=GROUP_NAME)

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

        if HasPermissionAll('hg.admin')('group edit'):

            #we're global admin, we're ok and we can create TOP level groups

            allow_empty_group = True

        elif not c.repo_group.parent_group:

            allow_empty_group = True

        else:

            allow_empty_group = False

        self.__load_defaults(allow_empty_group=allow_empty_group,

                             exclude_group_ids=[c.repo_group.group_id])

        repo_group_form = RepoGroupForm(

            edit=True,

            old_data=c.repo_group.get_dict(),

                #HOOKS

                sett = Ui.get_by_key(Ui.HOOK_UPDATE)

                sett.ui_active = form_result['hooks_changegroup_update']

                Session().add(sett)

                sett = Ui.get_by_key(Ui.HOOK_REPO_SIZE)

                sett.ui_active = form_result['hooks_changegroup_repo_size']

                Session().add(sett)

                sett = Ui.get_by_key(Ui.HOOK_PUSH)

                sett.ui_active = form_result['hooks_changegroup_push_logger']

                Session().add(sett)

                sett = Ui.get_by_key(Ui.HOOK_PULL)

                sett.ui_active = form_result['hooks_outgoing_pull_logger']

                Session().add(sett)

                ## EXTENSIONS

                sett = Ui.get_by_key('largefiles')

                if not sett: