def test_json_body_alternate_charset(self):
     from pyramid.compat import json
     request = self._makeOne({'REQUEST_METHOD':'POST'})
     inp = text_(
         b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf',
         'utf-8'
         )
     if PY3: # pragma: no cover
         body = bytes(json.dumps({'a':inp}), 'utf-16')
     else:
         body = json.dumps({'a':inp}).decode('utf-8').encode('utf-16')
     request.body = body
     request.content_type = 'application/json; charset=utf-16'
     self.assertEqual(request.json_body, {'a':inp})

 def notify_observers(self, msg):
     out = json.dumps(msg)
     for obs in self.observers:
         obs.put(out)
         obs.put(StopIteration)
     # for now just kill observers once a message is sent instead
     # of playing with chunked encoding
     self.observers = []

 def _render(value, system):
     request = system.get('request')
     if request is not None:
         response = request.response
         ct = response.content_type
         if ct == response.default_content_type:
             response.content_type = 'application/json'
     return json.dumps(value, default=default_encoder)

 def test_json_body_alternate_charset(self):
     from pyramid.compat import json
     request = self._makeOne({'REQUEST_METHOD':'POST'})
     request.charset = 'latin-1'
     la = unicode('La Pe\xc3\xb1a', 'utf-8')
     body = json.dumps({'a':la}, encoding='latin-1')
     request.body = body
     self.assertEqual(request.json_body, {'a':la})

 def _render(value, system):
     request = system.get("request")
     if request is not None:
         response = request.response
         ct = response.content_type
         if ct == response.default_content_type:
             response.content_type = "application/json"
     return json.dumps(value)

    def _makeDummyRequest(self, request_data=None):
        from pyramid.testing import DummyRequest
        request = DummyRequest()
        request.matched_route = DummyRoute('JSON-RPC')
        if request_data is not None:
            request.body = json.dumps(request_data)
            request.content_length = len(request.body)

        return request

 def add_observer(self, cursor=None):
     obs = self.Observer(game=self)
     if cursor == self.cursor or cursor is None:
         self.observers.append(obs)
     else:
         msg = json.dumps(self.updates[cursor+1])
         obs.put(msg)
         obs.put(StopIteration)
     return obs

 def serialize(self):
     tracking = {
         'events': self.events,
         'alias': self.user_id if self.alias else None,
         'identify': self.user_id if self.user_id else None
     }
     return {
         'api_token': self.api_token,
         'tracking': tracking,
         'tracking_json': json.dumps(tracking)
     }

def jsonrpc_error_response(error, id=None):
    """ Marshal a Python Exception into a webob ``Response``
    object with a body that is a JSON string suitable for use as
    a JSON-RPC response with a content-type of ``application/json``
    and return the response."""

    body = json.dumps({"jsonrpc": "2.0", "id": id, "error": error.as_dict()})

    response = Response(body)
    response.content_type = "application/json"
    response.content_length = len(body)
    return response

 def test_view_callable_cls_with_dict(self):
     target = self._makeOne()
     view_callable = target(DummyView)
     request = testing.DummyRequest()
     params = {'jsonrpc':'2.0', 'method':'dummy_rpc', 
               'params':dict(a=3, b=4), 'id':'test'}
     body = json.dumps(params)
     request.json_body = params
     request.rpc_args = dict(a=3, b=4)
     context = object()
     result = view_callable(context, request)
     self.assertEqual(result, 7)

    def test_view_callable_cls_with_invalid_args(self):
        from pyramid_rpc.jsonrpc import JsonRpcParamsInvalid

        target = self._makeOne()
        view_callable = target(DummyView)
        request = testing.DummyRequest()
        params = {'jsonrpc':'2.0', 'method':'dummy_rpc', 
                  'params':[], 'id':'test'}
        body = json.dumps(params)
        request.json_body = params
        request.rpc_args = []
        context = object()
        self.assertRaises(JsonRpcParamsInvalid, view_callable, context, request)

def view_calendar(context, request):

    kotti_calendar_resources.need()
    locale_name = get_locale_name(request)
    if locale_name in fullcalendar_locales:
        fullcalendar_locales[locale_name].need()
    else:  # pragma: no cover (safety belt only, should never happen)
        fullcalendar_locales["en"].need()

    session = DBSession()
    now = datetime.datetime.now()
    query = session.query(Event).filter(Event.parent_id == context.id)
    future = or_(Event.start > now, Event.end > now)
    upcoming = query.filter(future).order_by(Event.start).all()
    past = query.filter(Event.start < now).order_by(desc(Event.start)).all()
    upcoming = [event for event in upcoming if
                has_permission('view', event, request)]
    past = [event for event in past if
            has_permission('view', event, request)]

    fmt = '%Y-%m-%d %H:%M:%S'
    fullcalendar_events = []
    for event in (upcoming + past):
        json_event = {
            'title': event.title,
            'url': resource_url(event, request),
            'start': event.start.strftime(fmt),
            'allDay': event.all_day,
            }
        if event.end:
            json_event['end'] = event.end.strftime(fmt)
        fullcalendar_events.append(json_event)

    fullcalendar_options = {
        'header': {
            'left': 'prev,next today',
            'center': 'title',
            'right': 'month,agendaWeek,agendaDay'
        },
        'eventSources': context.feeds,
        'weekends': context.weekends,
        'events': fullcalendar_events,
        }

    return {
        'api': template_api(context, request),
        'upcoming_events': upcoming,
        'past_events': past,
        'fullcalendar_options': json.dumps(fullcalendar_options),
        }

 def test_it_with_no_id(self):
     def view(request):
         return request.rpc_args[0]
     config = self.config
     config.include('pyramid_rpc.jsonrpc')
     config.add_jsonrpc_endpoint('rpc', '/api/jsonrpc')
     config.add_jsonrpc_method(view, endpoint='rpc', method='dummy')
     app = config.make_wsgi_app()
     app = TestApp(app)
     params = {'jsonrpc': '2.0', 'method': 'dummy', 'params': [2, 3]}
     resp = app.post('/api/jsonrpc', content_type='application/json',
                       params=json.dumps(params))
     self.assertEqual(resp.status_int, 204)
     self.assertEqual(resp.body, '')

 def test_it_with_invalid_method(self):
     config = self.config
     config.include('pyramid_rpc.jsonrpc')
     config.add_jsonrpc_endpoint('rpc', '/api/jsonrpc')
     app = config.make_wsgi_app()
     app = TestApp(app)
     params = {'jsonrpc': '2.0', 'id': 5, 'method': 'foo', 'params': [2, 3]}
     resp = app.post('/api/jsonrpc', content_type='application/json',
                       params=json.dumps(params))
     self.assertEqual(resp.status_int, 200)
     self.assertEqual(resp.content_type, 'application/json')
     result = json.loads(resp.body)
     self.assertEqual(result['id'], 5)
     self.assertEqual(result['jsonrpc'], '2.0')
     self.assertEqual(result['error']['code'], -32601)

def search(context, request):
    sr = get_search_results(context, request)
    artists, albums, tracks, criteria = sr["artists"], sr["albums"], sr["tracks"], sr["criteria"]
    return dict(results=json.dumps({
        "artists": render_artists(artists,
                                  request,
                                  context),
        "albums": render_albums(context,
                                request,
                                albums or [],
                                show_artist=True)["items"],
        "tracks": render_tracks(tracks,
                                request,
                                show_artist=True),
        "criteria": criteria}), criteria=criteria)

    def view(self):
        """ Default view for :class:`kotti_calendar.resources.Calendar`

        :result: Dictionary needed to render the template.
        :rtype: dict
        """

        kotti_calendar_resources.need()
        lang_all_js.need()

        return {
            'api': template_api(self.context, self.request),
            'upcoming_events': self.upcoming_events,
            'past_events': self.past_events,
            'fullcalendar_options': json.dumps(self.fullcalendar_options),
            'event_url': self.event_url,
            }

    def _render(value, system):
        request = system.get("request")
        if request is not None:
            rpc_id = getattr(request, "rpc_id", None)
            response = request.response

            if rpc_id is None:
                response.status = 204
                del response.content_type
                return ""

            ct = response.content_type
            if ct == response.default_content_type:
                response.content_type = "application/json"

            out = {"jsonrpc": "2.0", "id": rpc_id, "result": value}
            return json.dumps(out)

    def test_it(self):
        try:
            # Pyramid 1.1
            from pyramid.renderers import null_renderer
            renderer = null_renderer
        except ImportError:
            # Pyramid 1.0
            renderer = None
        from pyramid.config import Configurator
        from pyramid_rpc.jsonrpc import jsonrpc_endpoint
        from pyramid_rpc.jsonrpc import JsonRpcViewMapper
        config = Configurator()
        config.add_route('JSON-RPC', 'apis/rpc')
        config.add_view(jsonrpc_endpoint, route_name='JSON-RPC')
        def dummy_rpc(request, a, b):
            return a + b
        config.add_view(route_name='JSON-RPC', name='dummy_rpc',
                        view=dummy_rpc, mapper=JsonRpcViewMapper,
                        renderer=renderer)
        
        config.add_route('JSON-RPC-CLS', 'apis/rpc/cls')
        config.add_view(jsonrpc_endpoint, route_name='JSON-RPC-CLS')
        config.add_view(route_name='JSON-RPC-CLS', name='dummy_rpc',
                        view=DummyView, mapper=JsonRpcViewMapper,
                        renderer=renderer)

        app = config.make_wsgi_app()
        import webtest
        app = webtest.TestApp(app)
        params = {'jsonrpc': '2.0', 'method': 'dummy_rpc',
                  'params': [2, 3], 'id': 'test'}
        body = json.dumps(params)
        res = app.post('/apis/rpc', params=body,
                       content_type='application/json')
        data = json.loads(res.body)
        self.assertEqual(data['id'], 'test')
        self.assertEqual(data['jsonrpc'], '2.0')
        self.assertEqual(data['result'], 5)
        
        res = app.post('/apis/rpc/cls', params=body,
                       content_type='application/json')
        data = json.loads(res.body)
        self.assertEqual(data['id'], 'test')
        self.assertEqual(data['jsonrpc'], '2.0')
        self.assertEqual(data['result'], 5)

    def _render(value, system):
        request = system.get('request')
        if request is not None:
            rpc_id = getattr(request, 'rpc_id', None)
            if rpc_id is None:
                raise HTTPNoContent()

            response = request.response
            ct = response.content_type
            if ct == response.default_content_type:
                response.content_type = 'application/json'

            out = {
                'jsonrpc' : JSONRPC_VERSION,
                'id' : rpc_id,
                'result' : value,
            }
            return json.dumps(out)

def view_calendar(context, request):

    kotti_calendar_resources.need()
    locale_name = get_locale_name(request)
    if locale_name in fullcalendar_locales:
        fullcalendar_locales[locale_name].need()
    else:  # pragma: no cover (safety belt only, should never happen)
        fullcalendar_locales["en"].need()

    session = DBSession()
    now = datetime.datetime.now()
    query = session.query(Event).filter(Event.parent_id == context.id)
    future = or_(Event.start > now, Event.end > now)
    upcoming = query.filter(future).order_by(Event.start).all()
    past = query.filter(Event.start < now).order_by(desc(Event.start)).all()
    upcoming = [event for event in upcoming if has_permission("view", event, request)]
    past = [event for event in past if has_permission("view", event, request)]

    fmt = "%Y-%m-%d %H:%M:%S"
    fullcalendar_events = []
    for event in upcoming + past:
        json_event = {
            "title": event.title,
            "url": resource_url(event, request),
            "start": event.start.strftime(fmt),
            "allDay": event.all_day,
        }
        if event.end:
            json_event["end"] = event.end.strftime(fmt)
        fullcalendar_events.append(json_event)

    fullcalendar_options = {
        "header": {"left": "prev,next today", "center": "title", "right": "month,agendaWeek,agendaDay"},
        "eventSources": context.feeds,
        "weekends": context.weekends,
        "events": fullcalendar_events,
    }

    return {
        "api": template_api(context, request),
        "upcoming_events": upcoming,
        "past_events": past,
        "fullcalendar_options": json.dumps(fullcalendar_options),
    }