# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import inspect

import json

import logging

import types

import urllib

from itertools import izip_longest

from paste.response import replace_header

from pylons.controllers import WSGIController

from pylons.controllers.util import Response

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

HTTPBadRequest, HTTPError

from rhodecode.model.db import User

from rhodecode.lib.auth import AuthUser

            return jsonrpc_error(message='Invalid API KEY')

        self._error = None

        try:

            self._func = self._find_method()

        except AttributeError, e:

            return jsonrpc_error(message=str(e))

        # now that we have a method, add self._req_params to

        # self.kargs and dispatch control to WGIController

        argspec = inspect.getargspec(self._func)

        arglist = argspec[0][1:]

        default_empty = types.NotImplementedType

        kwarglist = list(izip_longest(reversed(arglist),reversed(defaults),

                                fillvalue=default_empty))

        # this is little trick to inject logged in user for 

        # perms decorators to work they expect the controller class to have

        # rhodecode_user attribute set

        self.rhodecode_user = auth_u

        # This attribute will need to be first param of a method that uses

        # api_key, which is translated to instance of user at that name

        USER_SESSION_ATTR = 'apiuser'

    def _dispatch_call(self):

        """

        Implement dispatch interface specified by WSGIController

        """

        try:

            raw_response = self._inspect_call(self._func)

            if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

        except JSONRPCError as e:

            self._error = str(e)

        except Exception as e:

            json_exc = JSONRPCError('Internal server error')

            self._error = str(json_exc)

        if self._error is not None:

            raw_response = None

        response = dict(result=raw_response, error=self._error)

        try:

            return json.dumps(response)

        except TypeError, e:

            log.debug('Error encoding response: %s', e)

import traceback

import logging

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import HasPermissionAllDecorator

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

class ApiController(JSONRPCController):

    """

    API Controller

    Each method needs to have USER as argument this is then based on given

    API_KEY propagated as instance of user object

    """

    @HasPermissionAllDecorator('hg.admin')

    def pull(self, apiuser, repo):

        """

        Dispatch pull action on given repo

        :param user:

        :param repo:

        """

        try:

            ScmModel().pull_changes(repo, self.rhodecode_user.username)

            return 'Pulled from %s' % repo

        except Exception:

            raise JSONRPCError('Unable to pull changes from "%s"' % repo)

    @HasPermissionAllDecorator('hg.admin')

    def create_user(self, apiuser, username, password, active, admin, name, 

                    lastname, email):

        """

        Creates new user

        q = Session.query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork))\

            .options(joinedload(Repository.user))\

            .options(joinedload(Repository.group))\

        return q.one()

    @classmethod

    def get_repo_forks(cls, repo_id):

        return Session.query(cls).filter(Repository.fork_id == repo_id)

    @property

    def just_name(self):

        return self.repo_name.split(os.sep)[-1]

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.group

        groups.insert(0, cur_gr)

        ret = Session.query(RhodeCodeUi)\

            .options(FromCache("sql_cache_short", "repository_repo_ui")).all()

        hg_ui = ret

        for ui_ in hg_ui:

            if ui_.ui_active:

                log.debug('settings ui from db[%s]%s:%s', ui_.ui_section,

                          ui_.ui_key, ui_.ui_value)

                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

        return baseui

    #==========================================================================

    # SCM PROPERTIES

    #==========================================================================

    def get_changeset(self, rev):

        return get_changeset_safe(self.scm_instance, rev)

    @property

    def tip(self):

        return self.get_changeset('tip')

    @property

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.by_repo_name(repo_id), 'repo_id')

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def pull_changes(self, repo_name, username):

        dbrepo = Repository.by_repo_name(repo_name)

        repo = dbrepo.scm_instance

        try:

            extras = {'ip': '',

                      'username': username,

                      'action': 'push_remote',

                      'repository': repo_name}

            #inject ui extra param to log this action via push logger

            for k, v in extras.items():

                repo._repo.ui.setconfig('rhodecode_extras', k, v)

            self.mark_for_invalidation(repo_name)

        except:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        if repo.alias == 'hg':

            from vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        message = safe_str(message)