# -*- 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)

        if update:

            sys.stdout.write('Updated config in %s\n' % self._conf_name)

        else:

            sys.stdout.write('Created new config in %s\n' % self._conf_name)

    def update_config(self, new_config):

        """

        Reads the JSON config updates it's values with new_config and

        saves it back as JSON dump

        :param new_config:

        """

        config = {}

        try:

            with open(self._conf_name, 'rb') as conf:

                config = json.load(conf)

        except IOError, e:

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        self.make_config(config)

    def load_config(self):

        """

        Loads config from file and returns loaded JSON object

        """

        try:

            with open(self._conf_name, 'rb') as conf:

                return  json.load(conf)

        except IOError, e:

            #sys.stderr.write(str(e) + '\n')

            pass

# -*- 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 kallithea.lib.compat import json

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']

        member_list = []

        for member in members:

            member_list.append(member["username"])

        return member_list

    def get_group(self, name):

        """Return group info."""

        args = {"usersgroupid": name}

        return self.post("get_user_group", args)

    def get_user(self, username):

        """Return user info."""

        args = {"userid": username}

        return self.post("get_user", args)

class LdapClient(object):

    def __init__(self, uri, user, key, base_dn):

        self.client = ldap.initialize(uri, trace_level=0)

        self.client.set_option(ldap.OPT_REFERRALS, 0)

        self.client.simple_bind(user, key)

        self.base_dn = base_dn

    def __del__(self):

        self.client.unbind()

    def get_groups(self):

        """Get all the groups in form of dict {group_name: group_info,...}."""

        searchFilter = "objectClass=groupOfUniqueNames"

        result = self.client.search_s(self.base_dn, ldap.SCOPE_SUBTREE,

                                      searchFilter)

        groups = {}

        for group in result:

            groups[group[1]['cn'][0]] = group[1]

        return groups

    def get_group_users(self, groups, group):

        """Returns all the users belonging to a single group.

        Based on the list of groups and memberships, returns all the

        users belonging to a single group, searching recursively.

        """

        users = []

        for member in groups[group]["uniqueMember"]:

            member = self.parse_member_string(member)

            if member[0] == "uid":

                users.append(member[1])

            elif member[0] == "cn":

                users += self.get_group_users(groups, member[1])

        return users

    def parse_member_string(self, member):

        """Parses the member string and returns a touple of type and name.

        Unique member can be either user or group. Users will have 'uid' as

        prefix while groups will have 'cn'.

        """

        member = member.split(",")[0]

        return member.split('=')

class LdapSync(object):

    def __init__(self):

        self.ldap_client = LdapClient(config.get("default", "ldap_uri"),

                                      config.get("default", "ldap_user"),

                                      config.get("default", "ldap_key"),

                                      config.get("default", "base_dn"))

        self.rhodocode_api = API(config.get("default", "api_url"),

                                          config.get("default", "api_key"))

    def update_groups_from_ldap(self):

        """Add all the groups from LDAP to Kallithea."""

        added = existing = 0

        groups = self.ldap_client.get_groups()

        for group in groups:

            try:

                self.kallithea_api.create_repo_group(group)

                added += 1

            except Exception:

                existing += 1

        return added, existing

    def update_memberships_from_ldap(self, group):

        """Update memberships based on the LDAP groups."""

        groups = self.ldap_client.get_groups()

        group_users = self.ldap_client.get_group_users(groups, group)

        # Delete memberships first from each group which are not part

        # of the group any more.

        members = self.kallithea_api.get_group_members(group)

import datetime

import functools

import decimal

import imp

def _is_aware(value):

    """

    Determines if a given datetime.time is aware.

    The logic is described in Python's docs:

    http://docs.python.org/library/datetime.html#datetime.tzinfo

    """

    return (value.tzinfo is not None

            and value.tzinfo.utcoffset(value) is not None)

def _obj_dump(obj):

    """

    Custom function for dumping objects to JSON, if obj has __json__ attribute

    or method defined it will be used for serialization

    :param obj:

    """

    if isinstance(obj, complex):

        return [obj.real, obj.imag]

    # See "Date Time String Format" in the ECMA-262 specification.

    # some code borrowed from django 1.4

    elif isinstance(obj, datetime.datetime):

        r = obj.isoformat()

        if obj.microsecond:

            r = r[:23] + r[26:]

        if r.endswith('+00:00'):

            r = r[:-6] + 'Z'

        return r

    elif isinstance(obj, datetime.date):

        return obj.isoformat()

    elif isinstance(obj, decimal.Decimal):

        return str(obj)

    elif isinstance(obj, datetime.time):

        if _is_aware(obj):

            raise ValueError("JSON can't represent timezone-aware times.")

        r = obj.isoformat()

        if obj.microsecond:

            r = r[:12]

        return r

    elif isinstance(obj, set):

        return list(obj)

    elif hasattr(obj, '__json__'):

        if callable(obj.__json__):

            return obj.__json__()

        else:

            return obj.__json__

    else:

        raise NotImplementedError

# Import simplejson

try:

    # import simplejson initially

    _sj = imp.load_module('_sj', *imp.find_module('simplejson'))

    def extended_encode(obj):

        try:

            return _obj_dump(obj)

        except NotImplementedError:

            pass

        raise TypeError("%r is not JSON serializable" % (obj,))

    # we handle decimals our own it makes unified behavior of json vs

    # simplejson

    sj_version = [int(x) for x in _sj.__version__.split('.')]

    major, minor = sj_version[0], sj_version[1]

    if major < 2 or (major == 2 and minor < 1):

        # simplejson < 2.1 doesnt support use_decimal

        _sj.dumps = functools.partial(_sj.dumps,

                                             default=extended_encode)

        _sj.dump = functools.partial(_sj.dump,

                                            default=extended_encode)

    else:

        _sj.dumps = functools.partial(_sj.dumps,

                                             default=extended_encode,

                                             use_decimal=False)

        _sj.dump = functools.partial(_sj.dump,

                                            default=extended_encode,

                                            use_decimal=False)

    simplejson = _sj

except ImportError:

    # no simplejson set it to None

    simplejson = None

try:

    # simplejson not found try out regular json module

    _json = imp.load_module('_json', *imp.find_module('json'))

    # extended JSON encoder for json

    class ExtendedEncoder(_json.JSONEncoder):

        def default(self, obj):

            try:

                return _obj_dump(obj)

            except NotImplementedError:

                pass

            raise TypeError("%r is not JSON serializable" % (obj,))

    # monkey-patch JSON encoder to use extended version

    _json.dumps = functools.partial(_json.dumps, cls=ExtendedEncoder)

    _json.dump = functools.partial(_json.dump, cls=ExtendedEncoder)

    stdlibjson = _json

except ImportError:

    stdlibjson = None

# set all available json modules

if simplejson:

    json = _sj

elif stdlibjson:

    json = _json

else:

    raise ImportError('Could not find any json modules')