def test_text_version(self):
"""
Text version operation
"""
# revert to text version
self.assertEquals(Text.objects.get(pk=1).get_versions_number(), 2)
resource = Resource(TextVersionRevertHandler)
request = HttpRequest()
request.method = 'POST'
setattr(request, 'POST', {})
response = resource(request,
key='text_key_1',
version_key='textversion_key_0',
emitter_format='json')
self.assertEquals(Text.objects.get(pk=1).get_versions_number(), 3)
# delete text version
resource = Resource(TextVersionDeleteHandler)
request = HttpRequest()
request.method = 'POST'
setattr(request, 'POST', {})
response = resource(request,
key='text_key_1',
version_key='textversion_key_0',
emitter_format='json')
self.assertEquals(Text.objects.get(pk=1).get_versions_number(), 2)
def urls(auth, baseurl=None):
from django.conf.urls.defaults import url
infoapi = Resource(handler=InfoHandler)
vendapi = Resource(handler=VendorHandler)
dataapi = Resource(handler=DataIdHandler, authentication=auth)
vidapi = Resource(handler=VendorIdsHandler, authentication=auth)
if baseurl is None:
baseurl = models.DataId._meta.app_label
if baseurl:
baseurl = '%s/' % baseurl
else:
baseurl = ''
return (
url(r'^%sversion/$' % baseurl, infoapi, {'version': True}),
url(r'^%stestdata/$' % baseurl, infoapi, {'testdata': True}),
url(r'^%sdata/$' % baseurl, dataapi),
url(r'^%sdata/(?P<code>.+)/$' % baseurl, dataapi),
url(r'^%svendor/$' % baseurl, vendapi),
url(r'^%svendor/(?P<code>.+)/$' % baseurl, vendapi),
url(r'^%svendorid/$' % baseurl, vidapi),
url(r'^%svendorid/(?P<vendor>.+)/$' % baseurl, vidapi),
#url(r'^%svendorid/(?P<vendor>.+)/(?P<type>.+)/$' % baseurl, vidapi),
#url(r'^data/(?P<emitter_format>.+)/$', dataapi),
#url(r'^data\.(?P<emitter_format>.+)', dataapi, name='blogposts'),
# automated documentation
url(r'^%s$' % baseurl, documentation_view),
)
def get_patterns(klass,
model,
app_path,
alternate_url_prefix=None,
fields=None,
search_fields=None,
**kwargs):
model_name = model.__name__.lower()
if not app_path == "":
app_path += ':'
if not alternate_url_prefix:
alternate_url_prefix = model_name
app_path += alternate_url_prefix
# Create Handler
# Give this new form class a reasonable name.
handler_class_name = model.__name__ + 'Handler'
# Class attributes for the new form class.
handler_class_attrs = {'model': model}
if fields:
handler_class_attrs['fields'] = fields
handler_class = type(handler_class_name, (klass.handler_klass, ),
handler_class_attrs)
handler = Resource(handler_class)
# Create AutoCompleteHandler
# Give this new form class a reasonable name.
ac_handler_class_name = model.__name__ + 'AutoCompleteHandler'
# Class attributes for the new form class.
ac_handler_class_attrs = {}
if search_fields:
ac_handler_class_attrs['search_fields'] = search_fields
ac_handler_class = type(ac_handler_class_name, (
handler_class,
klass.autocomplete_handler_klass,
), ac_handler_class_attrs)
auto_complete_handler = Resource(ac_handler_class)
return patterns(
'',
(r'^%s/' % alternate_url_prefix,
include(patterns(
'',
url(r'^$', handler, name='list'),
url(r'^autocomplete/$',
auto_complete_handler,
name='autocomplete_list'),
url(r'^(?P<id>\d+)/$', handler, name='show'),
),
namespace=alternate_url_prefix,
app_name=alternate_url_prefix)),
)
def h(name, require_auth=True):
"""Build a handler and mark it CSRF exempt"""
handler = getattr(handlers, '%sHandler' % name)
#auth = require_auth and HttpBasicAuthentication(realm='Badger API') or None
#auth = require_auth and OAuthAuthentication(realm='Badger API') or None
auth = require_auth and utils.API_AUTHENTICATION or None
resource = Resource(handler=handler, authentication=auth)
resource.csrf_exempt = True
return resource
def ExportGrid(request, grid_data, data_key=None):
'''
Grid导出
'''
format = request.REQUEST.get('format', '.xls')
if request.method == "GET" and format and (format not in ('.xls', '.pdf',
'.csv')):
resp = rc.BAD_REQUEST
resp.write(u':不支持的输出格式')
return resp
from dbapp.modelutils import default_fields
try:
'''得到字段名集合'''
#fields= grid.__fieldnames
#exclude = ['id']
allowed_methods = ('GET', )
'''动态构造 Resource'''
type_name = str("_%s_APIHandler" % (id(grid_data)))
type_bases = (ExportGridHandler, )
type_dict = {
'allowed_methods': ('GET', ),
#'fields': fields,
#'exclude':exclude,
'grid_data': grid_data[0:65000]
}
handler = type(type_name, type_bases, type_dict)
return Resource(handler=handler)(request, data_key)
except UnicodeError:
from django.http import HttpResponse
import traceback
traceback.print_exc()
resp = rc.BAD_REQUEST
resp.write(u':编码出错，请另作选择')
return resp
def __call__(self, *args, **kwargs):
if waffle.switch_is_active('drf'):
if self.with_viewset:
actions = {}
view_name = self.resource_name + 'ViewSet'
if self.only_detail:
actions = {
'get': 'retrieve',
'put': 'update',
'delete': 'delete',
}
else:
actions = {
'get': 'retrieve',
'post': 'create',
}
return (getattr(views_drf,
view_name).as_view(actions)(*args, **kwargs))
else:
view_name = self.resource_name + 'View'
return getattr(views_drf, view_name).as_view()(*args, **kwargs)
else:
if self.with_handler:
handler = getattr(handlers, self.resource_name + 'Handler')
return Resource(handler=handler, **ad)(*args, **kwargs)
else:
return (class_view(getattr(views, self.resource_name +
'View'))(*args, **kwargs))
def test_edit(self):
"""
Edit text
"""
resource = Resource(TextEditHandler)
request = HttpRequest()
session = {}
setattr(request, 'session', {})
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'POST'
setattr(
request, 'POST', {
'format': 'markdown',
'content': u'ggg',
'keep_comments': True,
'new_version': True,
'title': 'new title'
})
#setattr(request, 'flash' , {})
response = resource(request, key='text_key_2', emitter_format='json')
self.assertEquals(
Text.objects.get(pk=2).last_text_version.content, u'ggg')
def test_reponse_with_data_and_status_code(self):
response_data = dict(complex_response=dict(something='good',
something_else='great'))
class MyHandler(BaseHandler):
"""
Handler which returns a response w/ both data and a status code (201)
"""
allowed_methods = ('POST', )
def create(self, request):
resp = rc.CREATED
resp.content = response_data
return resp
resource = Resource(MyHandler)
request = HttpRequest()
request.method = 'POST'
response = resource(request, emitter_format='json')
self.assertEquals(201, response.status_code)
self.assertTrue(response._is_string, "Expected response content to be a string")
# compare the original data dict with the json response
# converted to a dict
self.assertEquals(response_data, simplejson.loads(response.content))
def api_count(request, app_label, model_name):
'''
返回模型记录的行数
'''
model = models.get_model(app_label, model_name)
handler = type(str("_%s_%s_APICounter" % (app_label, model_name)),
(APICountHandler, ), {'model': model})
return Resource(handler=handler, authentication=get_auth(request))(request)
def test_urlpatterns_with_resource(self):
# Resources for handlers with resource_uri attributes are discovered
# in a urlconf module and returned. The type of resource_uri is not
# checked; it must only be present and not None.
handler = type(b"\m/", (BaseHandler, ), {"resource_uri": True})
resource = Resource(handler)
module = self.make_module()
module.urlpatterns = patterns("", url("^metal", resource))
self.assertSetEqual({resource}, find_api_resources(module))
def test_nested_urlpatterns_with_handler(self):
# Resources are found in nested urlconfs.
handler = type(b"\m/", (BaseHandler, ), {"resource_uri": True})
resource = Resource(handler)
module = self.make_module()
submodule = self.make_module()
submodule.urlpatterns = patterns("", url("^metal", resource))
module.urlpatterns = patterns("", ("^genre/", include(submodule)))
self.assertSetEqual({resource}, find_api_resources(module))
def test_other_error(self):
"""
Verify that other exceptions thrown from a handler method result in a valid
HttpResponse object being returned from the error_handler method
"""
class MyHandler(BaseHandler):
def read(self, request):
raise Exception()
resource = Resource(MyHandler)
resource.display_errors = True
resource.email_errors = False
request = HttpRequest()
request.method = 'GET'
response = resource(request)
self.assertTrue(isinstance(response, HttpResponse), "Expected a response, not: %s"
% response)
def test_other_error(self):
"""
Verify that other exceptions thrown from a handler method result in a valid
HttpResponse object being returned from the error_handler method
"""
class MyHandler(BaseHandler):
def read(self, request):
raise Exception()
resource = Resource(MyHandler)
resource.display_errors = True
resource.email_errors = False
request = HttpRequest()
request.method = 'GET'
response = resource(request)
self.assertTrue(isinstance(response, HttpResponse), "Expected a response, not: %s"
% response)
def test_list_text_get(self):
"""
List texts anon
"""
resource = Resource(AnonymousTextListHandler)
request = HttpRequest()
setattr(request, 'user', None)
request.method = 'GET'
response = resource(request, emitter_format='json')
self.assertEquals(200, response.status_code)
self.assertEquals(2, len(simplejson.loads(response.content)))
def test_text_create(self):
request = FalseRequest(None)
nb_anon_texts = get_texts_with_perm(request, 'can_view_text').count()
nb_texts = Text.objects.count()
resource = Resource(TextListHandler)
# create one private text
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'POST'
setattr(request, 'POST', {
'content': 'test content',
'format': "markdown",
'title': 'my title'
})
response = resource(request, )
self.assertEquals(200, response.status_code)
self.assertTrue('key' in simplejson.loads(response.content).keys())
request = FalseRequest(None)
self.assertEqual(
get_texts_with_perm(request, 'can_view_text').count(),
nb_anon_texts) # NO more anon text
# create one text with anon observer
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'POST'
setattr(
request, 'POST', {
'content': 'test content',
'format': "markdown",
'title': 'my title',
'anon_role': 4
})
response = resource(request, )
self.assertEquals(200, response.status_code)
self.assertTrue('key' in simplejson.loads(response.content).keys())
self.assertEquals(
nb_texts + 2,
Text.objects.count()) # 2 more texts should have been created
request = FalseRequest(None)
self.assertEqual(
get_texts_with_perm(request, 'can_view_text').count(),
nb_anon_texts + 1) # one more anon accessible text available
def test_text_get_logged_in(self):
"""
Logged in as manager api call
"""
resource = Resource(AnonymousTextHandler)
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'GET'
response = resource(request, key='text_key_3', emitter_format='json')
self.assertEquals(200, response.status_code)
def test_list_text_logged_in(self):
"""
List texts manager
"""
resource = Resource(AnonymousTextListHandler)
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'GET'
response = resource(request, emitter_format='json')
self.assertEquals(200, response.status_code)
self.assertEquals(5, len(simplejson.loads(response.content)))
def test_type_error(self):
"""
Verify that type errors thrown from a handler method result in a valid
HttpResonse object being returned from the error_handler method
"""
class MyHandler(BaseHandler):
def read(self, request):
raise TypeError()
request = HttpRequest()
request.method = 'GET'
response = Resource(MyHandler)(request)
self.assertTrue(isinstance(response, HttpResponse), "Expected a response, not: %s"
% response)
def get_url_pattens(app_list):
"""Gets app list returns urls patterns"""
models = get_all_models(app_list, from_django=True)
urlpatterns = []
models_list = []
for model in models:
urlpatterns.append(url(r"^"+get_resource_name_for_model(model),\
create_resource(model)))
InfoHandler.set_models(models)
urlinfo = url(r"^info", Resource(InfoHandler, HttpBasicAuthentication()))
urlpatterns.append(urlinfo)
return patterns("", * urlpatterns)
def test_pre_edit(self):
"""
Pre edit text: should return number of comments to remove
"""
resource = Resource(TextPreEditHandler)
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'POST'
setattr(request, 'POST', {
'new_format': 'markdown',
'new_content': u'ggg'
})
setattr(request, 'flash', {})
response = resource(request, key='text_key_2', emitter_format='json')
self.assertEquals(response.content, '{"nb_removed": 3}')
def get_patterns(klass,
model,
app_path,
alternate_url_prefix=None,
fields=None,
search_fields=None,
**kwargs):
model_name = model.__name__.lower()
if not app_path == "":
app_path += ':'
if not alternate_url_prefix:
alternate_url_prefix = model_name
app_path += alternate_url_prefix
# Create Handler
# Give this new form class a reasonable name.
handler_class_name = model.__name__ + 'Handler'
# Class attributes for the new form class.
handler_class_attrs = {'model': model}
if fields:
handler_class_attrs['fields'] = fields
handler_class = type(handler_class_name, (klass.handler_klass, ),
handler_class_attrs)
handler = Resource(handler_class)
#TODO: figure out how you want to handle api/fis/fi
return patterns(
'',
(r'^%s/' % alternate_url_prefix,
include(patterns(
'',
url(r'^$',
handler, {'emitter_format': 'ext-json'},
name='list'),
url(r'^(?P<id>\d+)/$',
handler, {'emitter_format': 'ext-json'},
name='show'),
),
namespace=alternate_url_prefix,
app_name=alternate_url_prefix)),
)
def api_for_model(request, model, data_key=None, query_set=None):
'''
模型api 间接视图
'''
from dbapp.modelutils import default_fields
try:
fields = request.GET.get("fields", "")
if fields:
fields = fields.split(",")
if len(fields) == 0:
fields = None
if hasattr(model, 'Admin'):
if model.Admin:
if hasattr(model.Admin, 'api_fields'):
fields = model.Admin.api_fields
elif hasattr(model.Admin, "list_display"):
fields = model.Admin.list_display
if not fields:
fields = [
isinstance(f, models.ForeignKey) and f.name + "_id"
or f.name for f in model._meta.fields
if f.name not in default_fields
]
else:
of = fields
if hasattr(model.Admin, 'api_fields'):
of = model.Admin.api_fields
f = [i for i in fields if i.split("|")[0] in of]
fields = f
handler = type(
str("_%s_%s_APIHandler" % (id(model.Admin), model.__name__)),
(APIHandler, ), {
'model': model,
'fields': fields,
'qs': query_set,
})
return Resource(handler=handler,
authentication=get_auth(request))(request, data_key)
except UnicodeError:
from django.http import HttpResponse
import traceback
traceback.print_exc()
return HttpResponse(u"%s" % _(u'导出的内容与选择的编码不符'))
def test_text_get(self):
"""
Anonymous api call
"""
resource = Resource(AnonymousTextHandler)
request = HttpRequest()
setattr(request, 'user', None)
request.method = 'GET'
# get public text
response = resource(request, key='text_key_4', emitter_format='json')
self.assertEquals(200, response.status_code) # 401: forbidden
response_data = simplejson.loads(response.content)
self.assertEquals(response_data.get('created'), '2009-02-13 04:01:12')
# error: private text
response = resource(request, key='text_key_3', emitter_format='json')
self.assertEquals(401, response.status_code)
def test_delete_text_logged_in_fail(self):
"""
Delete text (and fail: insufficient rights)
"""
nb_texts = Text.objects.count()
resource = Resource(TextDeleteHandler)
request = HttpRequest()
user = User.objects.get(pk=3)
setattr(request, 'user', user)
request.method = 'POST'
setattr(request, 'POST', {})
setattr(request, 'flash', {})
response = resource(request, key='text_key_3', emitter_format='json')
self.assertEquals(401, response.status_code)
# no text deleted
self.assertEquals(nb_texts, Text.objects.count())
def test_delete_text_logged_in_works(self):
"""
Delete text
"""
nb_texts = Text.objects.count()
resource = Resource(TextDeleteHandler)
request = HttpRequest()
user = User.objects.get(pk=1)
setattr(request, 'user', user)
request.method = 'POST'
setattr(request, 'POST', {})
setattr(request, 'flash', {})
response = resource(request, key='text_key_3', emitter_format='json')
self.assertEquals(204, response.status_code)
# one text deleted
self.assertEquals(nb_texts - 1, Text.objects.count())
def urls(auth, baseurl = None):
from django.conf.urls.defaults import url
fundapi = Resource(handler=FundHandler, authentication=auth)
if baseurl is None:
baseurl = models.Position._meta.app_label
if baseurl:
baseurl = '%s/' % baseurl
else:
baseurl = ''
return (
#url(r'^%sversion/$' % baseurl, infoapi, {'version': True}),
#url(r'^%stestdata/$' % baseurl, infoapi, {'testdata': True}),
url(r'^%sfund/$' % baseurl, fundapi),
url(r'^%sfund/(?P<code>.+)/$' % baseurl, fundapi),
url(r'^%sfundteam/(?P<team>.+)/$' % baseurl, fundapi),
#url(r'^%s$' % baseurl, documentation_view),
)
def __call__(self, request, *args, **kwargs):
if request.method != 'GET' and not request.is_ajax():
return HttpResponse('Non-AJAX request', status=FORBIDDEN)
content_type_lower = request.META.get('CONTENT_TYPE', '').lower()
if content_type_lower == 'application/json; charset=utf-8':
request.META['CONTENT_TYPE'] = 'application/json'
elif content_type_lower != 'application/json':
request.META.pop('CONTENT_TYPE', None)
request.is_anonymous = request.is_half_anonymous = False
if request.user.is_authenticated():
request.dev_name = request.user.username
else:
access = getattr(self.handler, 'access', GET_ANONYMOUS)
if access == AUTHENTICATED:
return HttpResponse('Authentication required',
status=UNAUTHORIZED)
try:
request.dev_name = request.session['dev_name']
except KeyError:
if (access == HALF_ANONYMOUS or access == GET_ANONYMOUS
and request.method != 'GET'):
request.dev_name = request.session['dev_name'] = (
create_dev())
else:
request.dev_name = ANONYM_NAME
request.is_anonymous = True
request.is_half_anonymous = not request.is_anonymous
if not request.is_anonymous:
lock_path = ROOT.locks[request.dev_name]
request.lock = (lock_path.acquire_shared() if request.method
== 'GET' else lock_path.acquire_exclusive())
else:
request.lock = None
try:
return PistonResource.__call__(self, request, *args, **kwargs)
finally:
if request.lock:
request.lock.release()
def __call__(self, request, *args, **kwargs):
if request.method != 'GET' and not request.is_ajax():
return HttpResponse('Non-AJAX request', status=FORBIDDEN)
content_type_lower = request.META.get('CONTENT_TYPE', '').lower()
if content_type_lower == 'application/json; charset=utf-8':
request.META['CONTENT_TYPE'] = 'application/json'
elif content_type_lower != 'application/json':
request.META.pop('CONTENT_TYPE', None)
request.is_anonymous = request.is_half_anonymous = False
if request.user.is_authenticated():
request.dev_name = request.user.username
else:
access = getattr(self.handler, 'access', GET_ANONYMOUS)
if access == AUTHENTICATED:
return HttpResponse('Authentication required', status=UNAUTHORIZED)
try:
request.dev_name = request.session['dev_name']
except KeyError:
if (access == HALF_ANONYMOUS or
access == GET_ANONYMOUS and request.method != 'GET'):
request.dev_name = request.session['dev_name'] = (
create_dev())
else:
request.dev_name = ANONYM_NAME
request.is_anonymous = True
request.is_half_anonymous = not request.is_anonymous
if not request.is_anonymous:
lock_path = ROOT.locks[request.dev_name]
request.lock = (
lock_path.acquire_shared() if request.method == 'GET' else
lock_path.acquire_exclusive())
else:
request.lock = None
try:
return PistonResource.__call__(self, request, *args, **kwargs)
finally:
if request.lock:
request.lock.release()
# urls.py
from django.conf.urls.defaults import *
from piston.resource import Resource
from pfacts003.api.handlers import *
from pfacts003.protein_analysis.api import *
from pfacts003.intrepid.api import *
from pfacts003.phylo4j.api import *
sequence_classifier_handler = Resource(HMMBLASTSequenceClassifierHandler)
sequence_handler = Resource(SequenceHandler)
solr_uniprot_handler = Resource(SolrUniProtHandler)
solr_family_handler = Resource(SolrFamilyHandler)
solr_phog_handler = Resource(SolrPhogHandler)
phylofacts_search_handler = Resource(PhyloFactsSearchHandler)
fatcat_handler = Resource(FatCat)
fatcat_results_handler = Resource(FatCatResults)
fatcat_summary_handler = Resource(FatCatSummary)
fatcat_orthologs_handler = Resource(FatCatOrthologs)
fatcat2_handler = Resource(Fatcat2)
fatcat2_family_matches_handler = Resource(Fatcat2FamilyMatches)
fatcat2_functions_handler = Resource(Fatcat2Functions)
fatcat2_all_functions_handler = Resource(Fatcat2AllFunctions)
fatcat2_candidate_orthologs_handler = Resource(Fatcat2CandidateOrthologs)
fatcat2_all_candidate_orthologs_handler = Resource(
Fatcat2AllCandidateOrthologs)
fatcat2_other_sequence_matches_handler = Resource(Fatcat2OtherSequenceMatches)
fatcat2_enclosing_clades_handler = Resource(Fatcat2EnclosingClades)
fatcat2_distant_clades_handler = Resource(Fatcat2DistantClades)
fatcat2_tree_handler = Resource(Fatcat2Tree)
fatcat2_go_annotation_handler = Resource(Fatcat2GOAnnotation)
from django.conf.urls.defaults import *
from piston.resource import Resource
from piston.authentication import NoAuthentication
from confcomm.api import ConferenceProfileHandler, DjangoAuthentication, \
CohortHandler, CohortMemberHandler
auth = DjangoAuthentication()
noauth = NoAuthentication()
confprof_handler = Resource(ConferenceProfileHandler, authentication=auth)
cohort_handler = Resource(CohortHandler, authentication=noauth)
cohort_member_handler = Resource(CohortMemberHandler, authentication=auth)
# place app url patterns here
urlpatterns = patterns(
'confcomm.views',
url('^$', 'single_page', name='confcomm_app'),
url('^app/$', 'single_page', name='confcomm_app_full'),
url('^register/$', 'register', name='confcomm_register'),
url('^login/$', 'login', name='confcomm_login'),
url('^profile/$', 'profile', name='confcomm_profile'),
url('^profile/edit/$', 'profile_edit', name='confcomm_profile_edit'),
url('^profile/(?P<username>\.?\w+)/$', 'profile', name='confcomm_profile'),
# ajaxified
url('^send_invitation/$', 'send_invitation', name='confcomm_email'),
url('^update_avatar/$', 'update_avatar', name='confcomm_avatar'),
url('^piston/profile/(?P<username>\.?[\w\._-]+)/$',
confprof_handler, {'emitter_format': 'json'},
name="confcomm_profile_api"),
url('^piston/profile/$',
from django.conf.urls.defaults import patterns, include, url
from piston.resource import Resource
from piston.authentication import HttpBasicAuthentication
from api import handlers
#Auth BASIC
auth = HttpBasicAuthentication(realm="Test Auth")
ad = {'authentication': auth}
blog_handler = Resource(handler=handlers.BlogHandler, **ad)
tag_handler = Resource(handler=handlers.TagHandler, **ad)
urlpatterns = patterns(
'',
# Blog
url(r'^blog/(?P<blog_id>[^/]+)/$', blog_handler),
url(r'^blog/$', blog_handler),
# Tag
url(r'^tag/(?P<tag_id>[^/]+)/$', tag_handler),
url(r'^tag/$', tag_handler),
)
from django.conf.urls.defaults import patterns, include, url
from piston.resource import Resource
from piston.authentication import HttpBasicAuthentication
from api.handlers import ErrorHandler, ResponseHandler, RequestHandler
auth = HttpBasicAuthentication(realm="stardust")
ad = {'authentication': auth}
error_resource = Resource(handler=ErrorHandler, **ad)
response_resource = Resource(handler=ResponseHandler, **ad)
request_resource = Resource(handler=RequestHandler, **ad)
error_resource.csrf_exempt = True
response_resource.csrf_exempt = True
request_resource.csrf_exempt = True
urlpatterns = patterns('',
url(r'^error/$', error_resource),
url(r'^response/$', response_resource),
url(r'^request/$', request_resource),
)
from django.conf.urls.defaults import *
from piston.resource import Resource
from api.handlers import *
from piston.authentication import OAuthAuthentication
auth = OAuthAuthentication()
year_handler = Resource(YearHandler, authentication=auth)
camp_handler = Resource(ThemeCampHandler, authentication=auth)
art_handler = Resource(ArtInstallationHandler, authentication=auth)
event_handler = Resource(PlayaEventHandler, authentication=auth)
user_handler = Resource(UserHandler, authentication=auth)
cstreet_handler = Resource(CircularStreetHandler, authentication=auth)
tstreet_handler = Resource(TimeStreetHandler, authentication=auth)
infrastructure_handler = Resource(InfrastructureHandler, authentication=auth)
urlpatterns = patterns(
'',
url(r'^user/', user_handler),
url(r'^year/', year_handler),
url(r'^(?P<year_year>\d{4})/camp/(?P<camp_id>\d+)/$', camp_handler),
url(r'^(?P<year_year>\d{4})/camp/', camp_handler),
url(r'^(?P<year_year>\d{4})/art/(?P<art_id>\d+)/$', art_handler),
url(r'^(?P<year_year>\d{4})/art/', art_handler),
url(r'^(?P<year_year>\d{4})/event/(?P<playa_event_id>\d+)/$',
event_handler),
url(r'^(?P<year_year>\d{4})/event/', event_handler),
url(r'^(?P<year_year>\d{4})/cstreet/', cstreet_handler),
url(r'^(?P<year_year>\d{4})/tstreet/', tstreet_handler),
url(r'^(?P<year_year>\d{4})/infrastructure/', infrastructure_handler),
)
from piston.resource import Resource
from django.views.decorators.cache import cache_page
from handlers import VoteHandler
from handlers import BillHandler
from handlers import MemberHandler
from handlers import PartyHandler
from handlers import TagHandler
from handlers import AgendaHandler
from handlers import CommitteeHandler
from handlers import CommitteeMeetingHandler
from handlers import EventHandler
from resources import v2_api
vote_handler = cache_page(Resource(VoteHandler), 60*15)
bill_handler = cache_page(Resource(BillHandler), 60*15)
member_handler = cache_page(Resource(MemberHandler), 60*15)
party_handler = cache_page(Resource(PartyHandler), 60*15)
tag_handler = cache_page(Resource(TagHandler), 60*15)
agenda_handler = cache_page(Resource(AgendaHandler), 60*15)
committee_handler = cache_page(Resource(CommitteeHandler), 60*15)
committee_meeting_handler = cache_page(Resource(CommitteeMeetingHandler), 60*15)
event_handler = cache_page(Resource(EventHandler), 60*15)
urlpatterns = patterns('',
url(r'^vote/$', vote_handler, name='vote-handler'),
url(r'^vote/(?P<id>[0-9]+)/$', vote_handler, name='vote-handler'),
url(r'^bill/$', bill_handler, name='bill-handler'),
url(r'^bill/(?P<id>[0-9]+)/$', bill_handler, name='bill-handler'),
url(r'^bill/popular/$', bill_handler, name='popular-bills-handler', kwargs={'popular': True}),
