# Universal Subtitles, universalsubtitles.org # # Copyright (C) 2010 Participatory Culture Foundation # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero 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 Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see # http://www.gnu.org/licenses/agpl-3.0.html. from piston.emitters import Emitter from piston.utils import Mimer class PlainEmitter(Emitter): def render(self, request): return self.construct() Emitter.register('plain', PlainEmitter, 'text/plain; charset=utf-8') Mimer.register(lambda *a: None, ('text/plain',))
xml.endElement(key.split()[0]) else: xml.characters(smart_unicode(data)) def render(self, request): stream = StringIO.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() xml.startElement("Response", {}) self._to_xml(xml, self.construct()) xml.endElement("Response") xml.endDocument() return stream.getvalue() Emitter.register('custom_xml', CustomXmlEmitter, 'text/xml; charset=utf-8') Mimer.register(lambda *a: None, ('text/xml',)) class IpAuthentication(object): """IP Authentication handler """ def __init__(self, auth_func=authenticate, realm='API'): self.auth_func = auth_func self.realm = realm def is_authenticated(self, request): try: settings.API_ALLOWED_IP.index(request.META['REMOTE_ADDR']) return True except: return False
import yaml import logging from piston.handler import BaseHandler from piston.utils import rc, throttle, require_mime from piston.utils import Mimer, FormValidationError from vumi.webapp.api.models import URLCallback from vumi.webapp.api.forms import URLCallbackForm from vumi.webapp.api.utils import specify_fields # Complete reset, clear defaults - they're hard to debug Mimer.TYPES = {} # Specify the default Mime loader for YAML, Piston's YAML loader by default # tries to wrap the loaded YAML data in a dict, which for our conversation # YAML documents doesn't work. Mimer.register(yaml.safe_load, ('application/x-yaml',)) # Do nothing with incoming XML, leave the parsing for the handler Mimer.register(lambda *a: None, ('text/xml', 'application/xml')) # Do nothing with plain text, leave the parsing for the handler Mimer.register(lambda *a: None, ('text/plain; charset=utf-8',)) class ConversationHandler(BaseHandler): allowed_methods = ('POST',) @throttle(5, 10 * 60) # allow 5 times in 10 minutes @require_mime('yaml') def create(self, request): # menu = load_from_string(request.raw_post_data) # dump = dump_menu(menu) # debug logging.debug("Received a new conversation script "
def render(self, request): stream = StringIO.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() xml.startElement("response", {}) self._to_xml(xml, self.construct()) xml.endElement("response") xml.endDocument() return stream.getvalue() Emitter.register('xml', XMLEmitter, 'text/xml; charset=utf-8') Mimer.register(lambda *a: None, ('text/xml',)) class JSONEmitter(Emitter): """ JSON emitter, understands timestamps. """ def render(self, request): cb = request.GET.get('callback', None) seria = simplejson.dumps(self.construct(), cls=DateTimeAwareJSONEncoder, ensure_ascii=False, indent=4) # Callback if cb and is_valid_jsonp_callback_value(cb): return '%s(%s)' % (cb, seria) return seria
from django.conf.urls.defaults import * from django.http import HttpResponse from piston.resource import Resource from piston.authentication import HttpBasicAuthentication from piston.utils import Mimer from txtalert.apps.api.handlers import (SMSHandler, PCMHandler, SMSReceiptHandler, PatientHandler, ChangeRequestHandler, CallRequestHandler) # make sure Piston also accepts text/xml with charset=utf-8 Mimer.register(lambda *a: None, ('text/xml; charset=utf-8',)) http_basic_authentication = HttpBasicAuthentication() sms_receipt_handler = Resource(SMSReceiptHandler, http_basic_authentication) sms_handler = Resource(SMSHandler, http_basic_authentication) pcm_handler = Resource(PCMHandler, http_basic_authentication) patient_handler = Resource(PatientHandler) change_request_handler = Resource(ChangeRequestHandler, http_basic_authentication) call_request_handler = Resource(CallRequestHandler, http_basic_authentication) # SMS api urlpatterns = patterns('', url(r'^sms/receipt\.(?P<emitter_format>.+)$', sms_receipt_handler, {}, 'api-sms-receipt'), url(r'^sms/(?P<identifier>.+)/(?P<msisdn>[0-9]+)\.(?P<emitter_format>.+)$', sms_handler, {}, 'api-sms'), url(r'^sms\.(?P<emitter_format>.+)$', sms_handler, {}, 'api-sms'), url(r'^patient\.(?P<emitter_format>.+)$', patient_handler, {}, 'api-patient'), url(r'^request/change\.(?P<emitter_format>.+)$', change_request_handler, {}, 'api-req-change'), url(r'^request/call\.(?P<emitter_format>.+)$', call_request_handler, {}, 'api-req-call'), )
from api.handlers import CommentHandler from django.utils import simplejson from django.conf.urls.defaults import * from piston.resource import Resource from piston.authentication import HttpBasicAuthentication from piston.utils import Mimer auth = HttpBasicAuthentication(realm="Caesar") ad = { 'authentication': auth } # Workaround for django-piston bug in charset handling Mimer.register(simplejson.loads, ('application/json', 'application/json; charset=UTF-8',)) class CsrfExemptResource(Resource): def __init__(self, handler, authentication=None): super(CsrfExemptResource, self).__init__(handler, authentication) self.csrf_exempt = getattr(self.handler, 'csrf_exempt', True) comment_handler = CsrfExemptResource(CommentHandler, **ad) urlpatterns = patterns('', (r'^comments/', comment_handler), (r'^comment/(?P<comment_id>\d+)/', comment_handler) )
from piston.utils import Mimer from src.utils import pbutils Mimer.register(pbutils.loadPb, ('application/octet-stream')) from src.utils import customLogger apiLogger = customLogger.getApiLogger('api_trace.log')
else: xml.characters(smart_unicode(data)) def render(self, request): stream = StringIO.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() xml.startElement("Response", {}) self._to_xml(xml, self.construct()) xml.endElement("Response") xml.endDocument() return stream.getvalue() Emitter.register('custom_xml', CustomXmlEmitter, 'text/xml; charset=utf-8') Mimer.register(lambda *a: None, ('text/xml', )) class IpAuthentication(object): """IP Authentication handler """ def __init__(self, auth_func=authenticate, realm='API'): self.auth_func = auth_func self.realm = realm def is_authenticated(self, request): try: settings.API_ALLOWED_IP.index(request.META['REMOTE_ADDR']) return True except: return False
# Bit of surgery on piston internals, this fixes # https://github.com/simplejson/simplejson/issues/37 import json import simplejson from piston.utils import Mimer from piston import emitters emitters.simplejson = json Mimer.unregister(simplejson.loads) Mimer.register(json.loads, ('application/json',)) # Another bit to please django-piston from django.http import HttpResponse HttpResponse._get_content = HttpResponse.content.fget
from quarter.models import * from stockphoto.models import * from utility.dmp import diff_match_patch import utility def urlencoded(raw): first = [urllib.unquote_plus(part) for part in raw.split('&')] second = [] for part in first: sp = part.split('=') second.append([sp[0], '='.join(sp[1:])]) return dict(second) Mimer.register(urlencoded, ('application/x-www-form-urlencoded; charset=UTF-8',)) def insertProjectHistory(project, cell, new_value, model, id, field, user): current_value = getattr(model.objects.get(id=id), field) if current_value == None: current_value = '' elif type(current_value) == int: current_value = str(current_value) if new_value == None: new_value = '' elif type(new_value) == int: new_value = str(new_value) if new_value != current_value:
from django.utils.functional import update_wrapper from piston.decorator import decorator from piston.emitters import Emitter from piston.utils import Mimer, rc __author__ = 'ishai' class EmpeericJSONEncoder(simplejson.JSONEncoder): def default(self, o): if isinstance(o, datetime.datetime): d = time.mktime(o.utctimetuple()) return r"/Date(%u000)/" % d else: return super(EmpeericJSONEncoder, self).default(o) Mimer.register(lambda *a: None, ('application/x-www-form-urlencoded; charset=UTF-8',)) def parse_file_field(thing): if not thing: return None if isinstance(thing.field, XPImageField): c = Context({'photo' : thing }) html_template = loader.get_template('photo.json') if html_template == None: return None content = html_template.render(c) if content == u'': return None print content try: return simplejson.loads(content)
stream = StringIO.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() xml.startElement("response", {}) self._to_xml(xml, self.construct()) xml.endElement("response") xml.endDocument() return stream.getvalue() Emitter.register('xml', XMLEmitter, 'text/xml; charset=utf-8') Mimer.register(lambda *a: None, ('text/xml', )) class JSONEmitter(Emitter): """ JSON emitter, understands timestamps. """ def render(self, request): cb = request.GET.get('callback', None) seria = simplejson.dumps(self.construct(), cls=DateTimeAwareJSONEncoder, ensure_ascii=False, indent=4) # Callback if cb and is_valid_jsonp_callback_value(cb):
from piston.utils import Mimer from piston.emitters import Emitter from piston.doc import generate_doc from restful.emitters import HTMLEmitter #from story.api.handlers import StoryHandler #from project.api.handlers import ProjectHandler, ReleaseHandler #register emitter Emitter.register('html', HTMLEmitter, 'text/html; charset=utf-8') #register content-type Mimer.register(lambda *a: None, ('text/plain',)) #register document #docs = [generate_doc(StoryHandler), generate_doc(ReleaseHandler), generate_doc(ProjectHandler)]
stream = io.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() xml.startElement("response", {}) self._to_xml(xml, self.construct()) xml.endElement("response") xml.endDocument() return stream.getvalue() Emitter.register("xml", XMLEmitter, "text/xml; charset=utf-8") Mimer.register(lambda *a: None, ("text/xml", )) class JSONEmitter(Emitter): """ JSON emitter, understands timestamps. """ def render(self, request): cb = request.GET.get("callback", None) indent = None if settings.DEBUG: indent = 4 seria = json.dumps( self.construct(), cls=DateTimeAwareJSONEncoder, ensure_ascii=False,
import django.db.models from django.db.models.query import QuerySet from rest.resource import ExtResource from piston.emitters import Emitter, JSONEmitter from piston.utils import Mimer import json from actstream import action from rest.decorators import permissions_required def jquery_json_loads(*args, **kwargs): return json.loads(*args, **kwargs) Emitter.register('json_upload', JSONEmitter, 'text/html; charset=utf-8') Mimer.register(jquery_json_loads, ('application/json', 'application/json; charset=UTF-8',)) class RequestError(Exception): """ A class to control the execution flow exception of a request """ def __init__(self, msg, return_code): self.msg = msg self.return_code = return_code class BaseHandler(BaseHandler): update_fields = None permissions = None
from stockphoto.models import * from utility.dmp import diff_match_patch import utility def urlencoded(raw): first = [urllib.unquote_plus(part) for part in raw.split('&')] second = [] for part in first: sp = part.split('=') second.append([sp[0], '='.join(sp[1:])]) return dict(second) Mimer.register(urlencoded, ('application/x-www-form-urlencoded; charset=UTF-8', )) def insertProjectHistory(project, cell, new_value, model, id, field, user): current_value = getattr(model.objects.get(id=id), field) if current_value == None: current_value = '' elif type(current_value) == int: current_value = str(current_value) if new_value == None: new_value = '' elif type(new_value) == int: new_value = str(new_value)